Doxygen
Loading...
Searching...
No Matches
classdef.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2024 by Dimitri van Heesch.
4 *
5 * Permission to use, copy, modify, and distribute this software and its
6 * documentation under the terms of the GNU General Public License is hereby
7 * granted. No representations are made about the suitability of this software
8 * for any purpose. It is provided "as is" without express or implied warranty.
9 * See the GNU General Public License for more details.
10 *
11 * Documents produced by Doxygen are derivative works derived from the
12 * input used in their production; they are not affected by this license.
13 *
14 */
15
16#include <cstdio>
17#include <algorithm>
18
19#include "types.h"
20#include "classdef.h"
21#include "classlist.h"
22#include "entry.h"
23#include "doxygen.h"
24#include "membername.h"
25#include "message.h"
26#include "config.h"
27#include "util.h"
28#include "diagram.h"
29#include "language.h"
30#include "htmlhelp.h"
31#include "example.h"
32#include "outputlist.h"
33#include "dot.h"
34#include "dotclassgraph.h"
35#include "dotrunner.h"
36#include "defargs.h"
37#include "debug.h"
38#include "docparser.h"
39#include "searchindex.h"
40#include "vhdldocgen.h"
41#include "layout.h"
42#include "arguments.h"
43#include "memberlist.h"
44#include "groupdef.h"
45#include "filedef.h"
46#include "namespacedef.h"
47#include "membergroup.h"
48#include "definitionimpl.h"
49#include "symbolresolver.h"
50#include "fileinfo.h"
51#include "trace.h"
52#include "moduledef.h"
53
54//-----------------------------------------------------------------------------
55
57 const ArgumentLists *actualParams,uint32_t *actualParamIndex)
58{
59 //bool optimizeOutputJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
60 bool hideScopeNames = Config_getBool(HIDE_SCOPE_NAMES);
61 //printf("qualifiedNameWithTemplateParameters() localName=%s\n",qPrint(cd->localName()));
62 QCString scName;
63 const Definition *d=cd->getOuterScope();
64 if (d)
65 {
67 {
68 const ClassDef *ocd=toClassDef(d);
69 scName = ocd->qualifiedNameWithTemplateParameters(actualParams,actualParamIndex);
70 }
71 else if (!hideScopeNames)
72 {
73 scName = d->qualifiedName();
74 }
75 }
76
77 SrcLangExt lang = cd->getLanguage();
78 QCString scopeSeparator = getLanguageSpecificSeparator(lang);
79 if (!scName.isEmpty()) scName+=scopeSeparator;
80
81 bool isSpecialization = cd->localName().find('<')!=-1;
82 QCString clName = cd->className();
83 scName+=clName;
84 if (lang!=SrcLangExt::CSharp && !cd->templateArguments().empty())
85 {
86 if (actualParams && *actualParamIndex<actualParams->size())
87 {
88 const ArgumentList &al = actualParams->at(*actualParamIndex);
90 {
91 scName+=tempArgListToString(al,lang);
92 }
93 (*actualParamIndex)++;
94 }
95 else
96 {
98 {
99 scName+=tempArgListToString(cd->templateArguments(),lang);
100 }
101 }
102 }
103 //printf("qualifiedNameWithTemplateParameters: scope=%s qualifiedName=%s\n",qPrint(name()),qPrint(scName));
104 return scName;
105}
106
107static QCString makeDisplayName(const ClassDef *cd,bool includeScope)
108{
109 //bool optimizeOutputForJava = Config_getBool(OPTIMIZE_OUTPUT_JAVA);
110 SrcLangExt lang = cd->getLanguage();
111 //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
112 QCString n;
113 if (lang==SrcLangExt::VHDL)
114 {
116 }
117 else
118 {
119 if (includeScope)
120 {
122 }
123 else
124 {
125 n=cd->className();
126 }
127 }
128 if (cd->isAnonymous())
129 {
131 }
133 if (sep!="::")
134 {
135 n=substitute(n,"::",sep);
136 }
137 if (cd->compoundType()==ClassDef::Protocol && n.endsWith("-p"))
138 {
139 n="<"+n.left(n.length()-2)+">";
140 }
141 return n;
142}
143
144//-----------------------------------------------------------------------------
145
147{
148 if (lang==SrcLangExt::Fortran)
149 {
150 switch (compType)
151 {
152 case ClassDef::Class: return "module";
153 case ClassDef::Struct: return "type";
154 case ClassDef::Union: return "union";
155 case ClassDef::Interface: return "interface";
156 case ClassDef::Protocol: return "protocol";
157 case ClassDef::Category: return "category";
158 case ClassDef::Exception: return "exception";
159 default: return "unknown";
160 }
161 }
162 else
163 {
164 switch (compType)
165 {
166 case ClassDef::Class: return isJavaEnum ? "enum" : "class";
167 case ClassDef::Struct: return "struct";
168 case ClassDef::Union: return "union";
169 case ClassDef::Interface: return lang==SrcLangExt::ObjC ? "class" : "interface";
170 case ClassDef::Protocol: return "protocol";
171 case ClassDef::Category: return "category";
172 case ClassDef::Exception: return "exception";
173 case ClassDef::Service: return "service";
174 case ClassDef::Singleton: return "singleton";
175 default: return "unknown";
176 }
177 }
178}
179
180//-----------------------------------------------------------------------------
181
182
183/** Implementation of the ClassDef interface */
184class ClassDefImpl : public DefinitionMixin<ClassDefMutable>
185{
186 public:
187 ClassDefImpl(const QCString &fileName,int startLine,int startColumn,
188 const QCString &name,CompoundType ct,
189 const QCString &ref=QCString(),const QCString &fName=QCString(),
190 bool isSymbol=TRUE,bool isJavaEnum=FALSE);
191
192 DefType definitionType() const override { return TypeClass; }
193 std::unique_ptr<ClassDef> deepCopy(const QCString &name) const override;
194 void moveTo(Definition *) override;
195 CodeSymbolType codeSymbolType() const override;
196 QCString getOutputFileBase() const override;
197 QCString getInstanceOutputFileBase() const override;
198 QCString getSourceFileBase() const override;
199 QCString getReference() const override;
200 bool isReference() const override;
201 bool isLocal() const override;
202 ClassLinkedRefMap getClasses() const override;
203 bool hasDocumentation() const override;
204 bool hasDetailedDescription() const override;
205 QCString collaborationGraphFileName() const override;
206 QCString inheritanceGraphFileName() const override;
207 QCString displayName(bool includeScope=TRUE) const override;
208 CompoundType compoundType() const override;
209 QCString compoundTypeString() const override;
210 const BaseClassList &baseClasses() const override;
211 void updateBaseClasses(const BaseClassList &bcd) override;
212 const BaseClassList &subClasses() const override;
213 void updateSubClasses(const BaseClassList &bcd) override;
214 const MemberNameInfoLinkedMap &memberNameInfoLinkedMap() const override;
215 Protection protection() const override;
216 bool isLinkableInProject() const override;
217 bool isLinkable() const override;
218 bool isVisibleInHierarchy() const override;
219 bool visibleInParentsDeclList() const override;
220 const ArgumentList &templateArguments() const override;
221 FileDef *getFileDef() const override;
222 ModuleDef *getModuleDef() const override;
223 const MemberDef *getMemberByName(const QCString &) const override;
224 int isBaseClass(const ClassDef *bcd,bool followInstances,const QCString &templSpec) const override;
225 bool isSubClass(ClassDef *bcd,int level=0) const override;
226 bool isAccessibleMember(const MemberDef *md) const override;
227 const TemplateInstanceList &getTemplateInstances() const override;
228 const ClassDef *templateMaster() const override;
229 bool isTemplate() const override;
230 const IncludeInfo *includeInfo() const override;
231 const UsesClassList &usedImplementationClasses() const override;
232 const UsesClassList &usedByImplementationClasses() const override;
233 const ConstraintClassList &templateTypeConstraints() const override;
234 bool isTemplateArgument() const override;
235 const Definition *findInnerCompound(const QCString &name) const override;
238 const ArgumentLists *actualParams=nullptr,uint32_t *actualParamIndex=nullptr) const override;
239 bool isAbstract() const override;
240 bool isObjectiveC() const override;
241 bool isFortran() const override;
242 bool isCSharp() const override;
243 bool isFinal() const override;
244 bool isSealed() const override;
245 bool isPublished() const override;
246 bool isExtension() const override;
247 bool isForwardDeclared() const override;
248 bool isInterface() const override;
249 ClassDef *categoryOf() const override;
250 QCString className() const override;
251 MemberList *getMemberList(MemberListType lt) const override;
252 const MemberLists &getMemberLists() const override;
253 const MemberGroupList &getMemberGroups() const override;
254 const TemplateNameMap &getTemplateBaseClassNames() const override;
255 bool isUsedOnly() const override;
256 QCString anchor() const override;
257 bool isEmbeddedInOuterScope() const override;
258 bool isSimple() const override;
259 const ClassDef *tagLessReference() const override;
260 const MemberDef *isSmartPointer() const override;
261 bool isJavaEnum() const override;
262 QCString title() const override;
263 QCString generatedFromFiles() const override;
264 const FileList &usedFiles() const override;
265 const ArgumentList &typeConstraints() const override;
266 const ExampleList &getExamples() const override;
267 bool hasExamples() const override;
268 QCString getMemberListFileName() const override;
269 bool subGrouping() const override;
270 bool isSliceLocal() const override;
271 bool hasNonReferenceSuperClass() const override;
272 QCString requiresClause() const override;
273 StringVector getQualifiers() const override;
274 bool containsOverload(const MemberDef *md) const override;
275 bool isImplicitTemplateInstance() const override;
276
277 ClassDef *insertTemplateInstance(const QCString &fileName,int startLine,int startColumn,
278 const QCString &templSpec,bool &freshInstance) override;
279 void insertBaseClass(ClassDef *,const QCString &name,Protection p,Specifier s,const QCString &t=QCString()) override;
280 void insertSubClass(ClassDef *,Protection p,Specifier s,const QCString &t=QCString()) override;
281 void insertExplicitTemplateInstance(ClassDef *instance,const QCString &spec) override;
282 void setIncludeFile(FileDef *fd,const QCString &incName,bool local,bool force) override;
283 void insertMember(MemberDef *) override;
284 void insertUsedFile(const FileDef *) override;
285 bool addExample(const QCString &anchor,const QCString &name, const QCString &file) override;
286 void mergeCategory(ClassDef *category) override;
287 void setFileDef(FileDef *fd) override;
288 void setModuleDef(ModuleDef *mod) override;
289 void setSubGrouping(bool enabled) override;
290 void setProtection(Protection p) override;
291 void setGroupDefForAllMembers(GroupDef *g,Grouping::GroupPri_t pri,const QCString &fileName,int startLine,bool hasDocs) override;
292 void addInnerCompound(Definition *d) override;
293 void addUsedClass(ClassDef *cd,const QCString &accessName,Protection prot) override;
294 void addUsedByClass(ClassDef *cd,const QCString &accessName,Protection prot) override;
295 void setIsStatic(bool b) override;
296 void setCompoundType(CompoundType t) override;
297 void setClassName(const QCString &name) override;
298 void setClassSpecifier(TypeSpecifier spec) override;
299 void addQualifiers(const StringVector &qualifiers) override;
300 void setTemplateArguments(const ArgumentList &al) override;
301 void setTemplateBaseClassNames(const TemplateNameMap &templateNames) override;
302 void setTemplateMaster(const ClassDef *tm) override;
303 void setImplicitTemplateInstance(bool b) override;
304 void setTypeConstraints(const ArgumentList &al) override;
305 void addMemberToTemplateInstance(const MemberDef *md, const ArgumentList &templateArguments, const QCString &templSpec) override;
306 void addMembersToTemplateInstance(const ClassDef *cd,const ArgumentList &templateArguments,const QCString &templSpec) override;
307 void makeTemplateArgument(bool b=TRUE) override;
308 void setCategoryOf(ClassDef *cd) override;
309 void setUsedOnly(bool b) override;
310 void setTagLessReference(const ClassDef *cd) override;
311 void setMetaData(const QCString &md) override;
312 void findSectionsInDocumentation() override;
313 void addMembersToMemberGroup() override;
314 void addListReferences() override;
315 void addTypeConstraints() override;
316 void computeAnchors() override;
317 void mergeMembers() override;
318 void sortMemberLists() override;
320 void writeDocumentation(OutputList &ol) const override;
321 void writeDocumentationForInnerClasses(OutputList &ol) const override;
322 void writeMemberPages(OutputList &ol) const override;
323 void writeMemberList(OutputList &ol) const override;
324 void writeDeclaration(OutputList &ol,const MemberDef *md,bool inGroup,int indentLevel,
325 const ClassDef *inheritedFrom,const QCString &inheritId) const override;
326 void writeQuickMemberLinks(OutputList &ol,const MemberDef *md) const override;
327 void writePageNavigation(OutputList &ol) const override;
328 void writeSummaryLinks(OutputList &ol) const override;
329 void reclassifyMember(MemberDefMutable *md,MemberType t) override;
330 void writeInlineDocumentation(OutputList &ol) const override;
331 void writeDeclarationLink(OutputList &ol,bool &found,
332 const QCString &header,bool localNames) const override;
333 void removeMemberFromLists(MemberDef *md) override;
334 void setAnonymousEnumType() override;
335 void countMembers() override;
336 void sortAllMembersList() override;
337
339 const ClassDef *inheritedFrom,const QCString &inheritId) const override;
340 void writeTagFile(TextStream &) const override;
341
342 int countMembersIncludingGrouped(MemberListType lt,const ClassDef *inheritedFrom,bool additional) const override;
343 int countMemberDeclarations(MemberListType lt,const ClassDef *inheritedFrom,
344 MemberListType lt2,bool invert,bool showAlways,ClassDefSet &visitedClasses) const override;
345 void writeMemberDeclarations(OutputList &ol,ClassDefSet &visitedClasses,
346 MemberListType lt,const QCString &title,
347 const QCString &subTitle=QCString(),
348 bool showInline=FALSE,const ClassDef *inheritedFrom=nullptr,
349 MemberListType lt2=MemberListType::Invalid(),bool invert=FALSE,bool showAlways=FALSE) const override;
350 void setRequiresClause(const QCString &req) override;
351
352 // inheritance graph related members
353 CLASS_GRAPH_t hasInheritanceGraph() const override;
354 void overrideInheritanceGraph(CLASS_GRAPH_t e) override;
355
356 // collaboration graph related members
357 bool hasCollaborationGraph() const override;
358 void overrideCollaborationGraph(bool e) override;
359 private:
360 int countInheritedByNodes() const;
361 int countInheritsNodes() const;
362 int countInheritanceNodes() const;
364 void showUsedFiles(OutputList &ol) const;
365
366 void writeDocumentationContents(OutputList &ol,const QCString &pageTitle) const;
367 void internalInsertMember(MemberDef *md,Protection prot,bool addToAllList);
368 void addMemberToList(MemberListType lt,MemberDef *md,bool isBrief);
371 const ClassDef *inheritedFrom,bool invert,
372 bool showAlways) const;
373 void writeMemberDocumentation(OutputList &ol,MemberListType lt,const QCString &title,bool showInline=FALSE) const;
376 int indentLevel,const ClassDef *inheritedFrom,const QCString &inheritId) const;
377 void writeBriefDescription(OutputList &ol,bool exampleFlag) const;
378 void writeDetailedDescription(OutputList &ol,const QCString &pageType,bool exampleFlag,
379 const QCString &title,const QCString &anchor=QCString()) const;
380 void writeIncludeFiles(OutputList &ol) const;
382 void writeInheritanceGraph(OutputList &ol) const;
383 void writeCollaborationGraph(OutputList &ol) const;
384 void writeMemberGroups(OutputList &ol,bool showInline=FALSE) const;
385 void writeNestedClasses(OutputList &ol,const QCString &title) const;
386 void writeInlineClasses(OutputList &ol) const;
387 void startMemberDeclarations(OutputList &ol) const;
388 void endMemberDeclarations(OutputList &ol) const;
389 void startMemberDocumentation(OutputList &ol) const;
390 void endMemberDocumentation(OutputList &ol) const;
391 void writeAuthorSection(OutputList &ol) const;
392 void writeMoreLink(OutputList &ol,const QCString &anchor) const;
394
397 void addClassAttributes(OutputList &ol) const;
399 const ClassDef *inheritedFrom,bool invert,bool showAlways,
400 ClassDefSet &visitedClasses) const;
402 QCString &title,QCString &subtitle) const;
403 void addTypeConstraint(const QCString &typeConstraint,const QCString &type);
404 void writeTemplateSpec(OutputList &ol,const Definition *d,
405 const QCString &type,SrcLangExt lang) const;
406 void mergeMembersFromBaseClasses(bool mergeVirtualBaseClass);
408 private:
409 /*! file name that forms the base for the output file containing the
410 * class documentation. For compatibility with Qt (e.g. links via tag
411 * files) this name cannot be derived from the class name directly.
412 */
414
415 /*! file name used for the list of all members */
417
418 /*! file name used for the collaboration diagram */
420
421 /*! file name used for the inheritance graph */
423
424 /*! Include information about the header file should be included
425 * in the documentation. 0 by default, set by setIncludeFile().
426 */
427 std::unique_ptr<IncludeInfo> m_incInfo;
428
429 /*! List of base class (or super-classes) from which this class derives
430 * directly.
431 */
433
434 /*! List of sub-classes that directly derive from this class
435 */
437
438 /*! Namespace this class is part of
439 * (this is the inner most namespace in case of nested namespaces)
440 */
441 //NamespaceDef *m_nspace = nullptr;
442
443 /*! File this class is defined in */
444 FileDef *m_fileDef = nullptr;
445
446 /*! Module this class is defined in */
448
449 /*! List of all members (including inherited members) */
451
452 /*! Template arguments of this class */
454
455 /*! Type constraints for template parameters */
457
458 /*! Files that were used for generating the class documentation. */
460
461 /*! Examples that use this class */
463
464 /*! Holds the kind of "class" this is. */
466
467 /*! The protection level in which this class was found.
468 * Typically Public, but for nested classes this can also be Protected
469 * or Private.
470 */
472
473 /*! The inner classes contained in this class. Will be 0 if there are
474 * no inner classes.
475 */
477
478 /* classes for the collaboration diagram */
481
483
484 /*! Template instances that exists of this class, the key in the
485 * dictionary is the template argument list.
486 */
488
490
491 /*! The class this class is an instance of. */
492 const ClassDef *m_templateMaster = nullptr;
493
494 /*! local class name which could be a typedef'ed alias name. */
496
497 /*! If this class is a Objective-C category, then this points to the
498 * class which is extended.
499 */
501
503
504 /* user defined member groups */
506
507 /*! Is this an abstract class? */
508 bool m_isAbstract = false;
509
510 /*! Is the class part of an unnamed namespace? */
511 bool m_isStatic = false;
512
513 /*! TRUE if classes members are merged with those of the base classes. */
514 bool m_membersMerged = false;
515
516 /*! TRUE if the class is defined in a source file rather than a header file. */
517 bool m_isLocal = false;
518
519 bool m_isTemplArg = false;
520
521 /*! Does this class group its user-grouped members
522 * as a sub-section of the normal (public/protected/..)
523 * groups?
524 */
525 bool m_subGrouping = false;
526
527 /** Reason of existence is a "use" relation */
528 bool m_usedOnly = false;
529
530 /** List of titles to use for the summary */
532
533 /** Is this a simple (non-nested) C structure? */
534 bool m_isSimple = false;
535
536 /** Does this class overloaded the -> operator? */
537 const MemberDef *m_arrowOperator = nullptr;
538
539 const ClassDef *m_tagLessRef = nullptr;
540
541 /** Does this class represent a Java style enum? */
542 bool m_isJavaEnum = false;
543
545
547
548 /** C++20 requires clause */
550
552
554 CLASS_GRAPH_t m_typeInheritanceGraph = CLASS_GRAPH_t::NO;
555
557};
558
559std::unique_ptr<ClassDef> createClassDef(
560 const QCString &fileName,int startLine,int startColumn,
561 const QCString &name,ClassDef::CompoundType ct,
562 const QCString &ref,const QCString &fName,
563 bool isSymbol,bool isJavaEnum)
564{
565 return std::make_unique<ClassDefImpl>(fileName,startLine,startColumn,name,ct,ref,fName,isSymbol,isJavaEnum);
566}
567//-----------------------------------------------------------------------------
568
570{
571 public:
572 ClassDefAliasImpl(const Definition *newScope,const ClassDef *cd)
573 : DefinitionAliasMixin(newScope,cd) { init(); }
574 ~ClassDefAliasImpl() override { deinit(); }
576
577 DefType definitionType() const override { return TypeClass; }
578
579 const ClassDef *getCdAlias() const { return toClassDef(getAlias()); }
580 std::unique_ptr<ClassDef> deepCopy(const QCString &name) const override {
582 }
583 void moveTo(Definition *) override {}
584
586 { return getCdAlias()->codeSymbolType(); }
588 { return getCdAlias()->getOutputFileBase(); }
592 { return getCdAlias()->getSourceFileBase(); }
593 QCString getReference() const override
594 { return getCdAlias()->getReference(); }
595 bool isReference() const override
596 { return getCdAlias()->isReference(); }
597 bool isLocal() const override
598 { return getCdAlias()->isLocal(); }
600 { return getCdAlias()->getClasses(); }
601 bool hasDocumentation() const override
602 { return getCdAlias()->hasDocumentation(); }
603 bool hasDetailedDescription() const override
604 { return getCdAlias()->hasDetailedDescription(); }
609 QCString displayName(bool includeScope=TRUE) const override
610 { return makeDisplayName(this,includeScope); }
611 CompoundType compoundType() const override
612 { return getCdAlias()->compoundType(); }
614 { return getCdAlias()->compoundTypeString(); }
615 const BaseClassList &baseClasses() const override
616 { return getCdAlias()->baseClasses(); }
617 const BaseClassList &subClasses() const override
618 { return getCdAlias()->subClasses(); }
621 Protection protection() const override
622 { return getCdAlias()->protection(); }
623 bool isLinkableInProject() const override
624 { return getCdAlias()->isLinkableInProject(); }
625 bool isLinkable() const override
626 { return getCdAlias()->isLinkable(); }
627 bool isVisibleInHierarchy() const override
628 { return getCdAlias()->isVisibleInHierarchy(); }
629 bool visibleInParentsDeclList() const override
630 { return getCdAlias()->visibleInParentsDeclList(); }
631 const ArgumentList &templateArguments() const override
632 { return getCdAlias()->templateArguments(); }
633 FileDef *getFileDef() const override
634 { return getCdAlias()->getFileDef(); }
635 ModuleDef *getModuleDef() const override
636 { return getCdAlias()->getModuleDef(); }
637 const MemberDef *getMemberByName(const QCString &s) const override
638 { return getCdAlias()->getMemberByName(s); }
639 int isBaseClass(const ClassDef *bcd,bool followInstances,const QCString &templSpec) const override
640 { return getCdAlias()->isBaseClass(bcd,followInstances,templSpec); }
641 bool isSubClass(ClassDef *bcd,int level=0) const override
642 { return getCdAlias()->isSubClass(bcd,level); }
643 bool isAccessibleMember(const MemberDef *md) const override
644 { return getCdAlias()->isAccessibleMember(md); }
646 { return getCdAlias()->getTemplateInstances(); }
647 const ClassDef *templateMaster() const override
648 { return getCdAlias()->templateMaster(); }
649 bool isTemplate() const override
650 { return getCdAlias()->isTemplate(); }
651 const IncludeInfo *includeInfo() const override
652 { return getCdAlias()->includeInfo(); }
659 bool isTemplateArgument() const override
660 { return getCdAlias()->isTemplateArgument(); }
661 const Definition *findInnerCompound(const QCString &name) const override
662 { return getCdAlias()->findInnerCompound(name); }
666 const ArgumentLists *actualParams=nullptr,uint32_t *actualParamIndex=nullptr) const override
667 { return makeQualifiedNameWithTemplateParameters(this,actualParams,actualParamIndex); }
668 bool isAbstract() const override
669 { return getCdAlias()->isAbstract(); }
670 bool isObjectiveC() const override
671 { return getCdAlias()->isObjectiveC(); }
672 bool isFortran() const override
673 { return getCdAlias()->isFortran(); }
674 bool isCSharp() const override
675 { return getCdAlias()->isCSharp(); }
676 bool isFinal() const override
677 { return getCdAlias()->isFinal(); }
678 bool isSealed() const override
679 { return getCdAlias()->isSealed(); }
680 bool isPublished() const override
681 { return getCdAlias()->isPublished(); }
682 bool isExtension() const override
683 { return getCdAlias()->isExtension(); }
684 bool isForwardDeclared() const override
685 { return getCdAlias()->isForwardDeclared(); }
686 bool isInterface() const override
687 { return getCdAlias()->isInterface(); }
688 ClassDef *categoryOf() const override
689 { return getCdAlias()->categoryOf(); }
690 QCString className() const override
691 { return getCdAlias()->className(); }
693 { return getCdAlias()->getMemberList(lt); }
694 const MemberLists &getMemberLists() const override
695 { return getCdAlias()->getMemberLists(); }
696 const MemberGroupList &getMemberGroups() const override
697 { return getCdAlias()->getMemberGroups(); }
700 bool isUsedOnly() const override
701 { return getCdAlias()->isUsedOnly(); }
702 QCString anchor() const override
703 { return getCdAlias()->anchor(); }
704 bool isEmbeddedInOuterScope() const override
705 { return getCdAlias()->isEmbeddedInOuterScope(); }
706 bool isSimple() const override
707 { return getCdAlias()->isSimple(); }
708 const ClassDef *tagLessReference() const override
709 { return getCdAlias()->tagLessReference(); }
710 const MemberDef *isSmartPointer() const override
711 { return getCdAlias()->isSmartPointer(); }
712 bool isJavaEnum() const override
713 { return getCdAlias()->isJavaEnum(); }
714 QCString title() const override
715 { return getCdAlias()->title(); }
717 { return getCdAlias()->generatedFromFiles(); }
718 const FileList &usedFiles() const override
719 { return getCdAlias()->usedFiles(); }
720 const ArgumentList &typeConstraints() const override
721 { return getCdAlias()->typeConstraints(); }
722 const ExampleList &getExamples() const override
723 { return getCdAlias()->getExamples(); }
724 bool hasExamples() const override
725 { return getCdAlias()->hasExamples(); }
727 { return getCdAlias()->getMemberListFileName(); }
728 bool subGrouping() const override
729 { return getCdAlias()->subGrouping(); }
730 bool isSliceLocal() const override
731 { return getCdAlias()->isSliceLocal(); }
732 bool hasNonReferenceSuperClass() const override
734 QCString requiresClause() const override
735 { return getCdAlias()->requiresClause(); }
737 { return getCdAlias()->getQualifiers(); }
738 bool containsOverload(const MemberDef *md) const override
739 { return getCdAlias()->containsOverload(md); }
740
741 int countMembersIncludingGrouped(MemberListType lt,const ClassDef *inheritedFrom,bool additional) const override
742 { return getCdAlias()->countMembersIncludingGrouped(lt,inheritedFrom,additional); }
744 MemberListType lt2,bool invert,bool showAlways,ClassDefSet &visitedClasses) const override
745 { return getCdAlias()->countMemberDeclarations(lt,inheritedFrom,lt2,invert,showAlways,visitedClasses); }
746
747 void writeDeclarationLink(OutputList &ol,bool &found,
748 const QCString &header,bool localNames) const override
749 { getCdAlias()->writeDeclarationLink(ol,found,header,localNames); }
750 bool isImplicitTemplateInstance() const override
752
753 void writeDocumentation(OutputList &ol) const override
757 void writeMemberPages(OutputList &ol) const override
758 { getCdAlias()->writeMemberPages(ol); }
759 void writeMemberList(OutputList &ol) const override
760 { getCdAlias()->writeMemberList(ol); }
761 void writeDeclaration(OutputList &ol,const MemberDef *md,bool inGroup,
762 int indentLevel, const ClassDef *inheritedFrom,const QCString &inheritId) const override
763 { getCdAlias()->writeDeclaration(ol,md,inGroup,indentLevel,inheritedFrom,inheritId); }
764 void writeQuickMemberLinks(OutputList &ol,const MemberDef *md) const override
765 { getCdAlias()->writeQuickMemberLinks(ol,md); }
766 void writeSummaryLinks(OutputList &ol) const override
767 { getCdAlias()->writeSummaryLinks(ol); }
768 void writePageNavigation(OutputList &ol) const override
772 void writeTagFile(TextStream &ol) const override
773 { getCdAlias()->writeTagFile(ol); }
775 MemberListType lt,const QCString &title,
776 const QCString &subTitle=QCString(),
777 bool showInline=FALSE,const ClassDef *inheritedFrom=nullptr,
778 MemberListType lt2=MemberListType::Invalid(),bool invert=FALSE,bool showAlways=FALSE) const override
779 { getCdAlias()->writeMemberDeclarations(ol,visitedClasses,lt,title,subTitle,showInline,inheritedFrom,lt2,invert,showAlways); }
781 const ClassDef *inheritedFrom,const QCString &inheritId) const override
782 { getCdAlias()->addGroupedInheritedMembers(ol,lt,inheritedFrom,inheritId); }
783
784 void updateBaseClasses(const BaseClassList &) override {}
785 void updateSubClasses(const BaseClassList &) override {}
786};
787
788std::unique_ptr<ClassDef> createClassDefAlias(const Definition *newScope,const ClassDef *cd)
789{
790 auto acd = std::make_unique<ClassDefAliasImpl>(newScope,cd);
791 //printf("cd name=%s localName=%s qualifiedName=%s qualifiedNameWith=%s displayName()=%s\n",
792 // qPrint(acd->name()),qPrint(acd->localName()),qPrint(acd->qualifiedName()),
793 // qPrint(acd->qualifiedNameWithTemplateParameters()),qPrint(acd->displayName()));
794 return acd;
795}
796
797//-----------------------------------------------------------------------------
798
799// constructs a new class definition
801 const QCString &defFileName,int defLine,int defColumn,
802 const QCString &nm,CompoundType ct,
803 const QCString &lref,const QCString &fName,
804 bool isSymbol,bool isJavaEnum)
805 : DefinitionMixin(defFileName,defLine,defColumn,removeRedundantWhiteSpace(nm),nullptr,nullptr,isSymbol)
806{
807 AUTO_TRACE("name={}",name());
808 setReference(lref);
809 m_compType = ct;
812 if (!fName.isEmpty())
813 {
815 }
816 else
817 {
818 m_fileName=compTypeString+name();
819 }
820 m_prot=Protection::Public;
821 //nspace=nullptr;
822 m_fileDef=nullptr;
823 m_moduleDef=nullptr;
824 m_subGrouping=Config_getBool(SUBGROUPING);
825 m_templateMaster =nullptr;
830 m_categoryOf = nullptr;
832 m_isSimple = Config_getBool(INLINE_SIMPLE_STRUCTS);
833 m_arrowOperator = nullptr;
834 m_tagLessRef = nullptr;
836 //QCString ns;
837 //extractNamespaceName(name,className,ns);
838 //printf("m_name=%s m_className=%s ns=%s\n",qPrint(m_name),qPrint(m_className),qPrint(ns));
839
840 // we cannot use getLanguage at this point, as setLanguage has not been called.
841 SrcLangExt lang = getLanguageFromFileName(defFileName);
842 if ((lang==SrcLangExt::Cpp || lang==SrcLangExt::ObjC) && guessSection(defFileName).isSource())
843 {
845 }
846 else
847 {
849 }
850 m_hasCollaborationGraph = Config_getBool(COLLABORATION_GRAPH);
852 m_memberListFileName = convertNameToFile(compTypeString+name()+"-members");
855 if (lref.isEmpty())
856 {
858 }
859 AUTO_TRACE_EXIT("m_fileName='{}'",m_fileName);
860}
861
862std::unique_ptr<ClassDef> ClassDefImpl::deepCopy(const QCString &name) const
863{
864 AUTO_TRACE("name='{}'",name);
865 auto result = std::make_unique<ClassDefImpl>(
867 std::string(),std::string(),true,m_isJavaEnum);
868 result->setBriefDescription(briefDescription(),briefFile(),briefLine());
869 result->setDocumentation(documentation(),docFile(),docLine());
870 result->setInbodyDocumentation(inbodyDocumentation(),inbodyFile(),inbodyLine());
871 result->setBodySegment(getStartDefLine(),getStartBodyLine(),getEndBodyLine());
872 result->setBodyDef(getBodyDef());
873 result->setLanguage(getLanguage());
874
875 // copy other members
876 result->m_memberListFileName = m_memberListFileName;
877 result->m_collabFileName = m_collabFileName;
878 result->m_inheritFileName = m_inheritFileName;
879 if (m_incInfo)
880 {
881 result->m_incInfo = std::make_unique<IncludeInfo>();
882 *(result->m_incInfo) = *m_incInfo;
883 }
884 result->m_inherits = m_inherits;
885 result->m_inheritedBy = m_inheritedBy;
886 result->m_fileDef = m_fileDef;
887 result->m_moduleDef = m_moduleDef;
888 result->m_tempArgs = m_tempArgs;
889 result->m_typeConstraints = m_typeConstraints;
890 result->m_files = m_files;
891 result->m_examples = m_examples;
892 result->m_compType = m_compType;
893 result->m_prot = m_prot;
894 result->m_usesImplClassList = m_usesImplClassList;
895 result->m_usedByImplClassList = m_usedByImplClassList;
896 result->m_constraintClassList = m_constraintClassList;
897 result->m_templateInstances = m_templateInstances;
898 result->m_templBaseClassNames = m_templBaseClassNames;
899 result->m_templateMaster = m_templateMaster;
900 result->m_className = m_className;
901 result->m_categoryOf = m_categoryOf;
902 result->m_isAbstract = m_isAbstract;
903 result->m_isStatic = m_isStatic;
904 result->m_membersMerged = m_membersMerged;
905 result->m_isLocal = m_isLocal;
906 result->m_isTemplArg = m_isTemplArg;
907 result->m_subGrouping = m_subGrouping;
908 result->m_usedOnly = m_usedOnly;
909 result->m_vhdlSummaryTitles = m_vhdlSummaryTitles;
910 result->m_isSimple = m_isSimple;
911 result->m_arrowOperator = m_arrowOperator;
912 result->m_tagLessRef = m_tagLessRef;
913 result->m_isJavaEnum = m_isJavaEnum;
914 result->m_spec = m_spec;
915 result->m_metaData = m_metaData;
916 result->m_requiresClause = m_requiresClause;
917 result->m_qualifiers = m_qualifiers;
918 result->m_hasCollaborationGraph = m_hasCollaborationGraph;
919 result->m_typeInheritanceGraph = m_typeInheritanceGraph;
920
921 // set new file name
923 result->m_fileName = compTypeString+name;
924 result->m_memberListFileName = convertNameToFile(compTypeString+name+"-members");
925 result->m_collabFileName = convertNameToFile(result->m_fileName+"_coll_graph");
926 result->m_inheritFileName = convertNameToFile(result->m_fileName+"_inherit_graph");
927 result->m_fileName = convertNameToFile(result->m_fileName);
928
929 // deep copy nested classes
930 for (const auto &innerCd : m_innerClasses)
931 {
932 QCString innerName = name+"::"+innerCd->localName();
933 if (Doxygen::classLinkedMap->find(innerName)==nullptr)
934 {
935 auto cd = Doxygen::classLinkedMap->add(innerName,innerCd->deepCopy(innerName));
936 result->addInnerCompound(cd);
938 if (cdm)
939 {
940 cdm->setOuterScope(result.get());
941 }
942 }
943 }
944
945 // copy all member list (and make deep copies of members)
946 for (auto &mni : m_allMemberNameInfoLinkedMap)
947 {
948 for (auto &mi : *mni)
949 {
950 const MemberDef *md=mi->memberDef();
951 auto newMd = md->deepCopy();
952 if (newMd)
953 {
954 auto mmd = toMemberDefMutable(newMd.get());
955 AUTO_TRACE_ADD("Copying member {}",mmd->name());
956 mmd->moveTo(result.get());
957
958 result->internalInsertMember(newMd.get(),newMd->protection(),true);
959
960 // also add to the global list (which will own newMd)
961 MemberName *mn = Doxygen::memberNameLinkedMap->add(newMd->name());
962 mn->push_back(std::move(newMd));
963 }
964 }
965 }
966
967 return result;
968}
969
971{
972 //printf("%s::moveTo(%s)\n",qPrint(name()),qPrint(scope->name()));
973 setOuterScope(scope);
975 {
976 m_fileDef = toFileDef(scope);
977 }
978 else if (scope->definitionType()==Definition::TypeModule)
979 {
980 m_moduleDef = toModuleDef(scope);
981 }
982}
983
988
989QCString ClassDefImpl::displayName(bool includeScope) const
990{
991 return makeDisplayName(this,includeScope);
992}
993
994// inserts a base/super class in the inheritance list
996 Specifier s,const QCString &t)
997{
998 //printf("*** insert base class %s into %s\n",qPrint(cd->name()),qPrint(name()));
999 m_inherits.emplace_back(cd,n,p,s,t);
1000 m_isSimple = FALSE;
1001}
1002
1003// inserts a derived/sub class in the inherited-by list
1005 Specifier s,const QCString &t)
1006{
1007 //printf("*** insert sub class %s into %s\n",qPrint(cd->name()),qPrint(name()));
1008 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
1009 if (!extractPrivate && cd->protection()==Protection::Private) return;
1010 m_inheritedBy.emplace_back(cd,QCString(),p,s,t);
1011 m_isSimple = FALSE;
1012}
1013
1015{
1016 for (auto &ml : m_memberLists)
1017 {
1018 if (!ml->listType().isDetailed())
1019 {
1021 }
1022 }
1023
1024 // add members inside sections to their groups
1025 for (const auto &mg : m_memberGroups)
1026 {
1027 if (mg->allMembersInSameSection() && m_subGrouping)
1028 {
1029 //printf("addToDeclarationSection(%s)\n",qPrint(mg->header()));
1030 mg->addToDeclarationSection();
1031 }
1032 }
1033}
1034
1035// adds new member definition to the class
1037 Protection prot,
1038 bool addToAllList
1039 )
1040{
1041 AUTO_TRACE("{} name={} isHidden={}",name(),md->name(),md->isHidden());
1042 if (md->isHidden()) return;
1043
1044 if (getLanguage()==SrcLangExt::VHDL)
1045 {
1047 m_vhdlSummaryTitles.insert(title.str());
1048 }
1049
1050 if (1 /*!isReference()*/) // changed to 1 for showing members of external
1051 // classes when HAVE_DOT and UML_LOOK are enabled.
1052 {
1053 bool isSimple=FALSE;
1054
1055 /********************************************/
1056 /* insert member in the declaration section */
1057 /********************************************/
1058 if (md->isRelated() && protectionLevelVisible(prot))
1059 {
1060 addMemberToList(MemberListType::Related(),md,TRUE);
1061 }
1062 else if (md->isFriend())
1063 {
1064 addMemberToList(MemberListType::Friends(),md,TRUE);
1065 }
1066 else
1067 {
1068 switch (md->memberType())
1069 {
1070 case MemberType::Service: // UNO IDL
1071 addMemberToList(MemberListType::Services(),md,TRUE);
1072 break;
1073 case MemberType::Interface: // UNO IDL
1074 addMemberToList(MemberListType::Interfaces(),md,TRUE);
1075 break;
1076 case MemberType::Signal: // Qt specific
1077 addMemberToList(MemberListType::Signals(),md,TRUE);
1078 break;
1079 case MemberType::DCOP: // KDE2 specific
1080 addMemberToList(MemberListType::DcopMethods(),md,TRUE);
1081 break;
1083 addMemberToList(MemberListType::Properties(),md,TRUE);
1084 break;
1085 case MemberType::Event:
1086 addMemberToList(MemberListType::Events(),md,TRUE);
1087 break;
1088 case MemberType::Slot: // Qt specific
1089 switch (prot)
1090 {
1091 case Protection::Protected:
1092 case Protection::Package: // slots in packages are not possible!
1093 addMemberToList(MemberListType::ProSlots(),md,TRUE);
1094 break;
1095 case Protection::Public:
1096 addMemberToList(MemberListType::PubSlots(),md,TRUE);
1097 break;
1098 case Protection::Private:
1099 addMemberToList(MemberListType::PriSlots(),md,TRUE);
1100 break;
1101 }
1102 break;
1103 default: // any of the other members
1104 if (md->isStatic())
1105 {
1106 if (md->isVariable())
1107 {
1108 switch (prot)
1109 {
1110 case Protection::Protected:
1111 addMemberToList(MemberListType::ProStaticAttribs(),md,TRUE);
1112 break;
1113 case Protection::Package:
1114 addMemberToList(MemberListType::PacStaticAttribs(),md,TRUE);
1115 break;
1116 case Protection::Public:
1117 addMemberToList(MemberListType::PubStaticAttribs(),md,TRUE);
1118 break;
1119 case Protection::Private:
1120 addMemberToList(MemberListType::PriStaticAttribs(),md,TRUE);
1121 break;
1122 }
1123 }
1124 else // function
1125 {
1126 switch (prot)
1127 {
1128 case Protection::Protected:
1129 addMemberToList(MemberListType::ProStaticMethods(),md,TRUE);
1130 break;
1131 case Protection::Package:
1132 addMemberToList(MemberListType::PacStaticMethods(),md,TRUE);
1133 break;
1134 case Protection::Public:
1135 addMemberToList(MemberListType::PubStaticMethods(),md,TRUE);
1136 break;
1137 case Protection::Private:
1138 addMemberToList(MemberListType::PriStaticMethods(),md,TRUE);
1139 break;
1140 }
1141 }
1142 }
1143 else // not static
1144 {
1145 if (md->isVariable())
1146 {
1147 switch (prot)
1148 {
1149 case Protection::Protected:
1150 addMemberToList(MemberListType::ProAttribs(),md,TRUE);
1151 break;
1152 case Protection::Package:
1153 addMemberToList(MemberListType::PacAttribs(),md,TRUE);
1154 break;
1155 case Protection::Public:
1156 addMemberToList(MemberListType::PubAttribs(),md,TRUE);
1157 isSimple=TRUE;
1158 break;
1159 case Protection::Private:
1160 addMemberToList(MemberListType::PriAttribs(),md,TRUE);
1161 break;
1162 }
1163 }
1164 else if (md->isTypedef() || md->isEnumerate() || md->isEnumValue())
1165 {
1166 switch (prot)
1167 {
1168 case Protection::Protected:
1169 addMemberToList(MemberListType::ProTypes(),md,TRUE);
1170 break;
1171 case Protection::Package:
1172 addMemberToList(MemberListType::PacTypes(),md,TRUE);
1173 break;
1174 case Protection::Public:
1175 addMemberToList(MemberListType::PubTypes(),md,TRUE);
1176 isSimple=!md->isEnumerate() &&
1177 !md->isEnumValue() &&
1178 md->typeString().find(")(")==-1; // func ptr typedef
1179 break;
1180 case Protection::Private:
1181 addMemberToList(MemberListType::PriTypes(),md,TRUE);
1182 break;
1183 }
1184 }
1185 else // member function
1186 {
1187 switch (prot)
1188 {
1189 case Protection::Protected:
1190 addMemberToList(MemberListType::ProMethods(),md,TRUE);
1191 break;
1192 case Protection::Package:
1193 addMemberToList(MemberListType::PacMethods(),md,TRUE);
1194 break;
1195 case Protection::Public:
1196 addMemberToList(MemberListType::PubMethods(),md,TRUE);
1197 break;
1198 case Protection::Private:
1199 addMemberToList(MemberListType::PriMethods(),md,TRUE);
1200 break;
1201 }
1202 }
1203 }
1204 break;
1205 }
1206 }
1207 if (!isSimple) // not a simple field -> not a simple struct
1208 {
1209 m_isSimple = FALSE;
1210 }
1211 //printf("adding %s simple=%d total_simple=%d\n",qPrint(name()),isSimple,m_isSimple);
1212
1213 /*******************************************************/
1214 /* insert member in the detailed documentation section */
1215 /*******************************************************/
1216 if ((md->isRelated() && protectionLevelVisible(prot)) || md->isFriend())
1217 {
1218 addMemberToList(MemberListType::RelatedMembers(),md,FALSE);
1219 }
1220 else if (md->isFunction() &&
1221 md->protection()==Protection::Private &&
1222 (md->virtualness()!=Specifier::Normal || md->isOverride() || md->isFinal()) &&
1223 Config_getBool(EXTRACT_PRIV_VIRTUAL))
1224 {
1225 addMemberToList(MemberListType::FunctionMembers(),md,FALSE);
1226 }
1227 else
1228 {
1229 switch (md->memberType())
1230 {
1231 case MemberType::Service: // UNO IDL
1232 addMemberToList(MemberListType::ServiceMembers(),md,FALSE);
1233 break;
1234 case MemberType::Interface: // UNO IDL
1235 addMemberToList(MemberListType::InterfaceMembers(),md,FALSE);
1236 break;
1238 addMemberToList(MemberListType::PropertyMembers(),md,FALSE);
1239 break;
1240 case MemberType::Event:
1241 addMemberToList(MemberListType::EventMembers(),md,FALSE);
1242 break;
1243 case MemberType::Signal: // fall through
1244 case MemberType::DCOP:
1245 addMemberToList(MemberListType::FunctionMembers(),md,FALSE);
1246 break;
1247 case MemberType::Slot:
1248 if (protectionLevelVisible(prot))
1249 {
1250 addMemberToList(MemberListType::FunctionMembers(),md,FALSE);
1251 }
1252 break;
1253 default: // any of the other members
1254 if (protectionLevelVisible(prot))
1255 {
1256 switch (md->memberType())
1257 {
1259 addMemberToList(MemberListType::TypedefMembers(),md,FALSE);
1260 break;
1262 addMemberToList(MemberListType::EnumMembers(),md,FALSE);
1263 break;
1265 addMemberToList(MemberListType::EnumValMembers(),md,FALSE);
1266 break;
1268 if (md->isConstructor() || md->isDestructor())
1269 {
1270 m_memberLists.get(MemberListType::Constructors(),MemberListContainer::Class)->push_back(md);
1271 }
1272 else
1273 {
1274 addMemberToList(MemberListType::FunctionMembers(),md,FALSE);
1275 }
1276 break;
1278 addMemberToList(MemberListType::VariableMembers(),md,FALSE);
1279 break;
1280 case MemberType::Define:
1281 warn(md->getDefFileName(),md->getDefLine()-1,"A define ({}) cannot be made a member of {}",
1282 md->name(), this->name());
1283 break;
1284 default:
1285 err("Unexpected member type '{}' found!\n",md->memberTypeName());
1286 }
1287 }
1288 break;
1289 }
1290 }
1291
1292 /*************************************************/
1293 /* insert member in the appropriate member group */
1294 /*************************************************/
1295 // Note: this must be done AFTER inserting the member in the
1296 // regular groups
1297 //addMemberToGroup(md,groupId);
1298
1299 }
1300
1301 if (md->virtualness()==Specifier::Pure)
1302 {
1303 m_isAbstract=true;
1304 }
1305
1306 if (md->name()=="operator->")
1307 {
1308 m_arrowOperator=md;
1309 }
1310
1311 if (addToAllList &&
1312 !(Config_getBool(HIDE_FRIEND_COMPOUNDS) &&
1313 md->isFriend() &&
1314 (md->typeString()=="friend class" ||
1315 md->typeString()=="friend struct" ||
1316 md->typeString()=="friend union")))
1317 {
1318 //printf("=======> adding member %s to class %s\n",qPrint(md->name()),qPrint(name()));
1319
1321 mni->push_back(std::make_unique<MemberInfo>(md,prot,md->virtualness(),false,false));
1322 }
1323
1324 // if we already created template instances before inserting this member (i.e. due to a typedef or using statement)
1325 // then we also need to insert the member in the template instance.
1326 for (const auto &ti : getTemplateInstances())
1327 {
1328 AUTO_TRACE_ADD("member {} of class {} with template instance {}\n",md->name(),name(),ti.templSpec);
1329 ClassDefMutable *cdm = toClassDefMutable(ti.classDef);
1330 if (cdm)
1331 {
1332 cdm->addMemberToTemplateInstance(md,templateArguments(),ti.templSpec);
1333 }
1334 }
1335
1336}
1337
1342
1343// compute the anchors for all members
1345{
1346 for (auto &ml : m_memberLists)
1347 {
1348 if (!ml->listType().isDetailed())
1349 {
1350 ml->setAnchors();
1351 }
1352 }
1353
1354 for (const auto &mg : m_memberGroups)
1355 {
1356 mg->setAnchors();
1357 }
1358}
1359
1361{
1362 for (const auto &mg : m_memberGroups)
1363 {
1364 mg->distributeMemberGroupDocumentation();
1365 }
1366}
1367
1369{
1373 for (const auto &mg : m_memberGroups)
1374 {
1375 mg->findSectionsInDocumentation(this);
1376 }
1377 for (auto &ml : m_memberLists)
1378 {
1379 if (!ml->listType().isDetailed())
1380 {
1381 ml->findSectionsInDocumentation(this);
1382 }
1383 }
1384}
1385
1386
1387// add a file name to the used files set
1389{
1390 if (fd==nullptr) return;
1391 auto it = std::find(m_files.begin(),m_files.end(),fd);
1392 if (it==m_files.end())
1393 {
1394 m_files.push_back(fd);
1395 }
1396 for (const auto &ti : m_templateInstances)
1397 {
1398 ClassDefMutable *cdm = toClassDefMutable(ti.classDef);
1399 if (cdm)
1400 {
1401 cdm->insertUsedFile(fd);
1402 }
1403 }
1404}
1405
1407{
1408 if (bcd.prot!=Protection::Public || bcd.virt!=Specifier::Normal)
1409 {
1410 ol.startTypewriter();
1411 ol.docify(" [");
1412 StringVector sl;
1413 if (bcd.prot==Protection::Protected) sl.emplace_back("protected");
1414 else if (bcd.prot==Protection::Private) sl.emplace_back("private");
1415 if (bcd.virt==Specifier::Virtual) sl.emplace_back("virtual");
1416 bool first=true;
1417 for (const auto &s : sl)
1418 {
1419 if (!first) ol.docify(", ");
1420 ol.docify(s);
1421 first=false;
1422 }
1423 ol.docify("]");
1424 ol.endTypewriter();
1425 }
1426}
1427
1429 const QCString &includeName,bool local, bool force)
1430{
1431 //printf("ClassDefImpl::setIncludeFile(%p,%s,%d,%d)\n",fd,includeName,local,force);
1432 if (!m_incInfo) m_incInfo = std::make_unique<IncludeInfo>();
1433 if ((!includeName.isEmpty() && m_incInfo->includeName.isEmpty()) ||
1434 (fd!=nullptr && m_incInfo->fileDef==nullptr)
1435 )
1436 {
1437 //printf("Setting file info\n");
1438 m_incInfo->fileDef = fd;
1439 m_incInfo->includeName = includeName;
1441 }
1442 if (force && !includeName.isEmpty())
1443 {
1444 m_incInfo->includeName = includeName;
1446 }
1447}
1448
1449// TODO: fix this: a nested template class can have multiple outer templates
1450//ArgumentList *ClassDefImpl::outerTemplateArguments() const
1451//{
1452// int ti;
1453// ClassDef *pcd=nullptr;
1454// int pi=0;
1455// if (m_tempArgs) return m_tempArgs;
1456// // find the outer most class scope
1457// while ((ti=name().find("::",pi))!=-1 &&
1458// (pcd=getClass(name().left(ti)))==0
1459// ) pi=ti+2;
1460// if (pcd)
1461// {
1462// return pcd->templateArguments();
1463// }
1464// return nullptr;
1465//}
1466
1467static void searchTemplateSpecs(/*in*/ const Definition *d,
1468 /*out*/ ArgumentLists &result,
1469 /*out*/ QCString &name,
1470 /*in*/ SrcLangExt lang)
1471{
1473 {
1474 if (d->getOuterScope())
1475 {
1476 searchTemplateSpecs(d->getOuterScope(),result,name,lang);
1477 }
1478 const ClassDef *cd=toClassDef(d);
1479 if (!name.isEmpty()) name+="::";
1480 QCString clName = d->localName();
1481 if (clName.endsWith("-p"))
1482 {
1483 clName = clName.left(clName.length()-2);
1484 }
1485 name+=clName;
1486 bool isSpecialization = d->localName().find('<')!=-1;
1487 if (!cd->templateArguments().empty())
1488 {
1489 result.push_back(cd->templateArguments());
1490 if (!isSpecialization)
1491 {
1492 name+=tempArgListToString(cd->templateArguments(),lang);
1493 }
1494 }
1495 }
1496 else
1497 {
1498 name+=d->qualifiedName();
1499 }
1500}
1501
1503 const QCString &type,SrcLangExt lang) const
1504{
1505 ArgumentLists specs;
1506 QCString name;
1507 searchTemplateSpecs(d,specs,name,lang);
1508 if (!specs.empty()) // class has template scope specifiers
1509 {
1511 for (const ArgumentList &al : specs)
1512 {
1513 ol.docify("template<");
1514 auto it = al.begin();
1515 while (it!=al.end())
1516 {
1517 Argument a = *it;
1519 d, // scope
1520 getFileDef(), // fileScope
1521 this, // self
1522 a.type, // text
1523 FALSE // autoBreak
1524 );
1525 if (!a.name.isEmpty())
1526 {
1527 ol.docify(" ");
1528 ol.docify(a.name);
1529 }
1530 if (a.defval.length()!=0)
1531 {
1532 ol.docify(" = ");
1533 ol.docify(a.defval);
1534 }
1535 ++it;
1536 if (it!=al.end()) ol.docify(", ");
1537 }
1538 ol.docify(">");
1539 ol.lineBreak();
1540 }
1541 if (!m_requiresClause.isEmpty())
1542 {
1543 ol.docify("requires ");
1545 d, // scope
1546 getFileDef(), // fileScope
1547 this, // self
1548 m_requiresClause, // text
1549 FALSE // autoBreak
1550 );
1551 ol.lineBreak();
1552 }
1553 ol.docify(type.lower()+" "+name);
1555 }
1556}
1557
1558void ClassDefImpl::writeBriefDescription(OutputList &ol,bool exampleFlag) const
1559{
1560 if (hasBriefDescription())
1561 {
1562 ol.startParagraph();
1563 ol.pushGeneratorState();
1565 ol.writeString(" - ");
1566 ol.popGeneratorState();
1568 briefLine(),
1569 this,
1570 nullptr,
1572 DocOptions()
1573 .setIndexWords(true)
1574 .setSingleLine(true));
1575 ol.pushGeneratorState();
1577 ol.writeString(" \n");
1579 ol.popGeneratorState();
1580
1581 if (hasDetailedDescription() || exampleFlag)
1582 {
1583 writeMoreLink(ol,anchor());
1584 }
1585
1586 ol.endParagraph();
1587 }
1588 ol.writeSynopsis();
1589}
1590
1592{
1593 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
1594
1595 ol.startTextBlock();
1596
1597 if (getLanguage()==SrcLangExt::Cpp)
1598 {
1600 }
1601
1602 // repeat brief description
1603 if (!briefDescription().isEmpty() && repeatBrief)
1604 {
1606 briefLine(),
1607 this,
1608 nullptr,
1610 DocOptions());
1611 }
1612 if (!briefDescription().isEmpty() && repeatBrief &&
1613 !documentation().isEmpty())
1614 {
1615 ol.pushGeneratorState();
1617 ol.writeString("\n\n");
1618 ol.popGeneratorState();
1619 }
1620 // write documentation
1621 if (!documentation().isEmpty())
1622 {
1623 ol.generateDoc(docFile(),
1624 docLine(),
1625 this,
1626 nullptr,
1627 documentation(),
1628 DocOptions()
1629 .setIndexWords(true));
1630 }
1631 // write type constraints
1633
1634 ol.generateDoc(
1635 docFile(),docLine(),
1636 this,
1637 nullptr, // memberDef
1639 DocOptions()
1640 .setIndexWords(true));
1641
1642 // write examples
1643 if (hasExamples())
1644 {
1645 ol.startExamples();
1646 ol.startDescForItem();
1648 ol.endDescForItem();
1649 ol.endExamples();
1650 }
1651 writeSourceDef(ol);
1652 ol.endTextBlock();
1653}
1654
1656{
1657 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
1658 bool sourceBrowser = Config_getBool(SOURCE_BROWSER);
1659 return ((!briefDescription().isEmpty() && repeatBrief) ||
1660 (!documentation().isEmpty() || m_tempArgs.hasTemplateDocumentation()) ||
1661 (sourceBrowser && getStartBodyLine()!=-1 && getBodyDef()));
1662}
1663
1664// write the detailed description for this class
1665void ClassDefImpl::writeDetailedDescription(OutputList &ol, const QCString &/*pageType*/, bool exampleFlag,
1666 const QCString &title,const QCString &anchor) const
1667{
1668 if (hasDetailedDescription() || exampleFlag)
1669 {
1670 ol.pushGeneratorState();
1672 ol.writeRuler();
1673 ol.popGeneratorState();
1674
1675 ol.pushGeneratorState();
1677 ol.writeAnchor(QCString(),anchor.isEmpty() ? QCString("details") : anchor);
1678 ol.popGeneratorState();
1679
1680 if (!anchor.isEmpty())
1681 {
1682 ol.pushGeneratorState();
1686 ol.popGeneratorState();
1687 }
1688
1689 ol.startGroupHeader("details");
1690 ol.parseText(title);
1691 ol.endGroupHeader();
1692
1694 }
1695 else
1696 {
1697 //writeTemplateSpec(ol,this,pageType);
1698 }
1699}
1700
1702{
1703 QCString result;
1704 SrcLangExt lang = getLanguage();
1705 size_t numFiles = m_files.size();
1706 if (lang==SrcLangExt::Fortran)
1707 {
1708 result = theTranslator->trGeneratedFromFilesFortran(
1709 getLanguage()==SrcLangExt::ObjC && m_compType==Interface ? Class : m_compType,
1710 numFiles==1);
1711 }
1712 else if (isJavaEnum())
1713 {
1714 result = theTranslator->trEnumGeneratedFromFiles(numFiles==1);
1715 }
1716 else if (m_compType==Service)
1717 {
1718 result = theTranslator->trServiceGeneratedFromFiles(numFiles==1);
1719 }
1720 else if (m_compType==Singleton)
1721 {
1722 result = theTranslator->trSingletonGeneratedFromFiles(numFiles==1);
1723 }
1724 else
1725 {
1726 result = theTranslator->trGeneratedFromFiles(
1727 getLanguage()==SrcLangExt::ObjC && m_compType==Interface ? Class : m_compType,
1728 numFiles==1);
1729 }
1730 return result;
1731}
1732
1734{
1735 ol.pushGeneratorState();
1737
1738
1739 ol.writeRuler();
1740 ol.pushGeneratorState();
1742 ol.startParagraph();
1744 ol.endParagraph();
1745 ol.popGeneratorState();
1749
1750 bool first=TRUE;
1751 for (const auto &fd : m_files)
1752 {
1753 if (first)
1754 {
1755 first=FALSE;
1756 ol.startItemList();
1757 }
1758
1759 ol.startItemListItem();
1760 QCString path=fd->getPath();
1761 if (Config_getBool(FULL_PATH_NAMES))
1762 {
1763 ol.docify(stripFromPath(path));
1764 }
1765
1766 QCString fname = fd->name();
1767 if (!fd->getVersion().isEmpty()) // append version if available
1768 {
1769 fname += " (" + fd->getVersion() + ")";
1770 }
1771
1772 // for HTML
1773 ol.pushGeneratorState();
1775 if (fd->generateSourceFile())
1776 {
1777 ol.writeObjectLink(QCString(),fd->getSourceFileBase(),QCString(),fname);
1778 }
1779 else if (fd->isLinkable())
1780 {
1781 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),QCString(),fname);
1782 }
1783 else
1784 {
1785 ol.startBold();
1786 ol.docify(fname);
1787 ol.endBold();
1788 }
1789 ol.popGeneratorState();
1790
1791 // for other output formats
1792 ol.pushGeneratorState();
1794 if (fd->isLinkable())
1795 {
1796 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),QCString(),fname);
1797 }
1798 else
1799 {
1800 ol.docify(fname);
1801 }
1802 ol.popGeneratorState();
1803
1804 ol.endItemListItem();
1805 }
1806 if (!first) ol.endItemList();
1807
1808 ol.popGeneratorState();
1809}
1810
1812{
1813 int count=0;
1814 for (const auto &ibcd : m_inheritedBy)
1815 {
1816 const ClassDef *icd=ibcd.classDef;
1817 if ( icd->isVisibleInHierarchy()) count++;
1818 }
1819 return count;
1820}
1821
1823{
1824 int count=0;
1825 for (const auto &ibcd : m_inherits)
1826 {
1827 const ClassDef *icd=ibcd.classDef;
1828 if ( icd->isVisibleInHierarchy()) count++;
1829 }
1830 return count;
1831}
1832
1837
1839{
1840 bool haveDot = Config_getBool(HAVE_DOT);
1841 auto classGraph = m_typeInheritanceGraph;
1842
1843 if (classGraph == CLASS_GRAPH_t::NO) return;
1844 // count direct inheritance relations
1845 int count=countInheritanceNodes();
1846
1847 bool renderDiagram = FALSE;
1848 if (haveDot && (classGraph==CLASS_GRAPH_t::YES || classGraph==CLASS_GRAPH_t::GRAPH))
1849 // write class diagram using dot
1850 {
1851 DotClassGraph inheritanceGraph(this,GraphType::Inheritance);
1852 if (inheritanceGraph.isTooBig())
1853 {
1854 warn_uncond("Inheritance graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
1855 name(), inheritanceGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
1856 }
1857 else if (!inheritanceGraph.isTrivial())
1858 {
1859 ol.pushGeneratorState();
1861 ol.startDotGraph();
1862 ol.parseText(theTranslator->trClassDiagram(displayName()));
1863 ol.endDotGraph(inheritanceGraph);
1864 ol.popGeneratorState();
1865 renderDiagram = TRUE;
1866 }
1867 }
1868 else if ((classGraph==CLASS_GRAPH_t::YES || classGraph==CLASS_GRAPH_t::GRAPH || classGraph==CLASS_GRAPH_t::BUILTIN) && count>0)
1869 // write class diagram using built-in generator
1870 {
1871 ClassDiagram diagram(this); // create a diagram of this class.
1872 ol.startClassDiagram();
1874 ol.parseText(theTranslator->trClassDiagram(displayName()));
1877 renderDiagram = TRUE;
1878 }
1879
1880 if (renderDiagram) // if we already show the inheritance relations graphically,
1881 // then hide the text version
1882 {
1884 }
1885
1886 count = countInheritsNodes();
1887 if (count>0)
1888 {
1889 auto replaceFunc = [this,&ol](size_t entryIndex)
1890 {
1891 for (size_t index=0; index<m_inherits.size() ; index++)
1892 {
1893 const BaseClassDef &bcd=m_inherits[index];
1894 const ClassDef *cd=bcd.classDef;
1895
1896 if (cd->isVisibleInHierarchy()) // filter on the class we want to show
1897 {
1898 if (index==entryIndex) // found the requested index
1899 {
1900 // use the class name but with the template arguments as given
1901 // in the inheritance relation
1903 cd->displayName(),bcd.templSpecifiers);
1904
1905 if (cd->isLinkable())
1906 {
1908 cd->getOutputFileBase(),
1909 cd->anchor(),
1910 displayName);
1911 }
1912 else
1913 {
1914 ol.docify(displayName);
1915 }
1916 return;
1917 }
1918 }
1919 }
1920 };
1921
1922 ol.startParagraph();
1923 writeMarkerList(ol,
1924 theTranslator->trInheritsList(count).str(),
1925 static_cast<size_t>(count),
1926 replaceFunc);
1927 ol.endParagraph();
1928 }
1929
1930 // write subclasses
1931 count = countInheritedByNodes();
1932 if (count>0)
1933 {
1934 auto replaceFunc = [this,&ol](size_t entryIndex)
1935 {
1936 for (size_t index=0; index<m_inheritedBy.size() ; index++)
1937 {
1938 const BaseClassDef &bcd=m_inheritedBy[index];
1939 const ClassDef *cd=bcd.classDef;
1940 if (cd->isVisibleInHierarchy()) // filter on the class we want to show
1941 {
1942 if (index==entryIndex) // found the requested index
1943 {
1944 if (cd->isLinkable())
1945 {
1948 }
1949 else
1950 {
1951 ol.docify(cd->displayName());
1952 }
1953 return;
1954 }
1955 }
1956 }
1957 };
1958
1959 ol.startParagraph();
1960 writeMarkerList(ol,
1961 theTranslator->trInheritedByList(count).str(),
1962 static_cast<size_t>(count),
1963 replaceFunc);
1964 ol.endParagraph();
1965 }
1966
1967 if (renderDiagram)
1968 {
1969 ol.enableAll();
1970 }
1971}
1972
1974{
1975 if (Config_getBool(HAVE_DOT) && m_hasCollaborationGraph /*&& Config_getBool(COLLABORATION_GRAPH)*/)
1976 {
1977 DotClassGraph usageImplGraph(this,GraphType::Collaboration);
1978 if (usageImplGraph.isTooBig())
1979 {
1980 warn_uncond("Collaboration graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
1981 name(), usageImplGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
1982 }
1983 else if (!usageImplGraph.isTrivial())
1984 {
1985 ol.pushGeneratorState();
1987 ol.startDotGraph();
1988 ol.parseText(theTranslator->trCollaborationDiagram(displayName()));
1989 ol.endDotGraph(usageImplGraph);
1990 ol.popGeneratorState();
1991 }
1992 }
1993}
1994
1995
1997{
1998 if (m_incInfo)
1999 {
2000 QCString nm;
2001 const StringVector &paths = Config_getList(STRIP_FROM_PATH);
2002 if (!paths.empty() && m_incInfo->fileDef)
2003 {
2004 QCString abs = m_incInfo->fileDef->absFilePath();
2005 QCString potential;
2006 size_t length = 0;
2007 for (const auto &s : paths)
2008 {
2009 FileInfo info(s);
2010 if (info.exists())
2011 {
2012 QCString prefix = info.absFilePath();
2013 if (prefix.at(prefix.length() - 1) != '/')
2014 {
2015 prefix += '/';
2016 }
2017
2018 if (prefix.length() > length &&
2019 qstricmp(abs.left(prefix.length()).data(), prefix.data()) == 0) // case insensitive compare
2020 {
2021 length = prefix.length();
2022 potential = abs.right(abs.length() - prefix.length());
2023 }
2024 }
2025 }
2026
2027 if (length > 0)
2028 {
2029 nm = potential;
2030 }
2031 }
2032
2033 if (nm.isEmpty())
2034 {
2035 nm = m_incInfo->includeName;
2036 }
2037
2038 ol.startParagraph();
2039 ol.docify(theTranslator->trDefinedIn()+" ");
2040 ol.startTypewriter();
2041 ol.docify("<");
2042 if (m_incInfo->fileDef)
2043 {
2044 ol.writeObjectLink(QCString(),m_incInfo->fileDef->includeName(),QCString(),nm);
2045 }
2046 else
2047 {
2048 ol.docify(nm);
2049 }
2050 ol.docify(">");
2051 ol.endTypewriter();
2052 ol.endParagraph();
2053 }
2054
2055 // Write a summary of the Slice definition including metadata.
2056 ol.startParagraph();
2057 ol.startTypewriter();
2058 if (!m_metaData.isEmpty())
2059 {
2060 ol.docify(m_metaData);
2061 ol.lineBreak();
2062 }
2063 if (m_spec.isLocal())
2064 {
2065 ol.docify("local ");
2066 }
2067 if (m_spec.isInterface())
2068 {
2069 ol.docify("interface ");
2070 }
2071 else if (m_spec.isStruct())
2072 {
2073 ol.docify("struct ");
2074 }
2075 else if (m_spec.isException())
2076 {
2077 ol.docify("exception ");
2078 }
2079 else
2080 {
2081 ol.docify("class ");
2082 }
2083 ol.docify(stripScope(name()));
2084 if (!m_inherits.empty())
2085 {
2086 if (m_spec.isInterface() || m_spec.isException())
2087 {
2088 ol.docify(" extends ");
2089 bool first=true;
2090 for (const auto &ibcd : m_inherits)
2091 {
2092 if (!first) ol.docify(", ");
2093 ClassDef *icd = ibcd.classDef;
2094 ol.docify(icd->name());
2095 first=false;
2096 }
2097 }
2098 else
2099 {
2100 // Must be a class.
2101 bool implements = false;
2102 for (const auto &ibcd : m_inherits)
2103 {
2104 ClassDef *icd = ibcd.classDef;
2105 if (icd->isInterface())
2106 {
2107 implements = true;
2108 }
2109 else
2110 {
2111 ol.docify(" extends ");
2112 ol.docify(icd->name());
2113 }
2114 }
2115 if (implements)
2116 {
2117 ol.docify(" implements ");
2118 bool first = true;
2119 for (const auto &ibcd : m_inherits)
2120 {
2121 ClassDef *icd = ibcd.classDef;
2122 if (icd->isInterface())
2123 {
2124 if (!first) ol.docify(", ");
2125 first = false;
2126 ol.docify(icd->name());
2127 }
2128 }
2129 }
2130 }
2131 }
2132 ol.docify(" { ... }");
2133 ol.endTypewriter();
2134 ol.endParagraph();
2135}
2136
2138{
2139 if (m_incInfo /*&& Config_getBool(SHOW_HEADERFILE)*/)
2140 {
2141 SrcLangExt lang = getLanguage();
2142 QCString nm=m_incInfo->includeName.isEmpty() ?
2143 (m_incInfo->fileDef ?
2144 m_incInfo->fileDef->docName() : QCString()
2145 ) :
2146 m_incInfo->includeName;
2147 if (!nm.isEmpty())
2148 {
2149 ol.startParagraph();
2150 ol.startTypewriter();
2151 ol.docify(::includeStatement(lang,m_incInfo->kind));
2152 ol.docify(::includeOpen(lang,m_incInfo->kind));
2153 ol.pushGeneratorState();
2155 ol.docify(nm);
2158 if (m_incInfo->fileDef)
2159 {
2160 ol.writeObjectLink(QCString(),m_incInfo->fileDef->includeName(),QCString(),nm);
2161 }
2162 else
2163 {
2164 ol.docify(nm);
2165 }
2166 ol.popGeneratorState();
2167 ol.docify(::includeClose(lang,m_incInfo->kind));
2168 ol.endTypewriter();
2169 ol.endParagraph();
2170 }
2171 }
2172}
2173
2174void ClassDefImpl::writeMemberGroups(OutputList &ol,bool showInline) const
2175{
2176 // write user defined member groups
2177 for (const auto &mg : m_memberGroups)
2178 {
2179 if (!mg->allMembersInSameSection() || !m_subGrouping) // group is in its own section
2180 {
2181 mg->writeDeclarations(ol,this,nullptr,nullptr,nullptr,nullptr,showInline);
2182 }
2183 else // add this group to the corresponding member section
2184 {
2185 //printf("addToDeclarationSection(%s)\n",qPrint(mg->header()));
2186 //mg->addToDeclarationSection();
2187 }
2188 }
2189}
2190
2192{
2193 // nested classes
2194 m_innerClasses.writeDeclaration(ol,nullptr,title,TRUE);
2195}
2196
2198{
2199 m_innerClasses.writeDocumentation(ol,this);
2200}
2201
2203{
2204 //printf("%s: ClassDefImpl::startMemberDocumentation()\n",qPrint(name()));
2205 if (Config_getBool(SEPARATE_MEMBER_PAGES))
2206 {
2209 }
2210}
2211
2213{
2214 //printf("%s: ClassDefImpl::endMemberDocumentation()\n",qPrint(name()));
2215 if (Config_getBool(SEPARATE_MEMBER_PAGES))
2216 {
2219 }
2220}
2221
2223{
2224 //printf("%s: ClassDefImpl::startMemberDeclarations()\n",qPrint(name()));
2226}
2227
2229{
2230 //printf("%s: ClassDefImpl::endMemberDeclarations()\n",qPrint(name()));
2231 bool inlineInheritedMembers = Config_getBool(INLINE_INHERITED_MEMB);
2232 if (!inlineInheritedMembers && countAdditionalInheritedMembers()>0)
2233 {
2234 ol.startMemberHeader("inherited");
2235 ol.parseText(theTranslator->trAdditionalInheritedMembers());
2236 ol.endMemberHeader();
2238 }
2239 ol.endMemberSections();
2240}
2241
2243{
2244 ol.pushGeneratorState();
2246 ol.writeString("\n");
2247 ol.startGroupHeader();
2248 ol.parseText(theTranslator->trAuthor(TRUE,TRUE));
2249 ol.endGroupHeader();
2250 ol.parseText(theTranslator->trGeneratedAutomatically(Config_getString(PROJECT_NAME)));
2251 ol.popGeneratorState();
2252}
2253
2254
2256{
2257 static bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
2258 ol.pushGeneratorState();
2260 bool first=TRUE;
2261 SrcLangExt lang = getLanguage();
2262
2263 if (lang!=SrcLangExt::VHDL)
2264 {
2265 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
2266 {
2267 if (lde->kind()==LayoutDocEntry::ClassNestedClasses &&
2268 m_innerClasses.declVisible()
2269 )
2270 {
2271 for (const auto &innerCd : m_innerClasses)
2272 {
2273 if (!innerCd->isAnonymous() &&
2274 !innerCd->isExtension() &&
2275 (innerCd->protection()!=Protection::Private || extractPrivate) &&
2276 innerCd->visibleInParentsDeclList()
2277 )
2278 {
2279 const LayoutDocEntrySection *ls = (const LayoutDocEntrySection*)lde.get();
2280 ol.writeSummaryLink(QCString(),"nested-classes",ls->title(lang),first);
2281 first=FALSE;
2282 break;
2283 }
2284 }
2285 }
2286 else if (lde->kind()==LayoutDocEntry::ClassAllMembersLink &&
2288 !Config_getBool(OPTIMIZE_OUTPUT_FOR_C)
2289 )
2290 {
2291 ol.writeSummaryLink(getMemberListFileName(),"all-members-list",theTranslator->trListOfAllMembers(),first);
2292 first=FALSE;
2293 }
2294 else if (lde->kind()==LayoutDocEntry::MemberDecl)
2295 {
2296 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
2297 if (lmd)
2298 {
2299 MemberList * ml = getMemberList(lmd->type);
2300 if (ml && ml->declVisible())
2301 {
2302 ol.writeSummaryLink(QCString(),ml->listType().toLabel(),lmd->title(lang),first);
2303 first=FALSE;
2304 }
2305 }
2306 }
2307 }
2308 }
2309 else // VDHL only
2310 {
2311 for (const auto &s : m_vhdlSummaryTitles)
2312 {
2313 ol.writeSummaryLink(QCString(),convertToId(s),s,first);
2314 first=FALSE;
2315 }
2316 }
2317 if (!first)
2318 {
2319 ol.writeString(" </div>\n");
2320 }
2321 ol.popGeneratorState();
2322}
2323
2328
2330{
2331 if (!isLinkableInProject() || isArtificial()) return;
2332 tagFile << " <compound kind=\"";
2333 if (isFortran() && (compoundTypeString() == "type"))
2334 tagFile << "struct";
2335 else
2336 tagFile << compoundTypeString();
2337 tagFile << "\"";
2338 if (isObjectiveC()) { tagFile << " objc=\"yes\""; }
2339 tagFile << ">\n";
2340 tagFile << " <name>" << convertToXML(name()) << "</name>\n";
2343 tagFile << " <filename>" << convertToXML(fn) << "</filename>\n";
2344 if (!anchor().isEmpty())
2345 {
2346 tagFile << " <anchor>" << convertToXML(anchor()) << "</anchor>\n";
2347 }
2348 QCString idStr = id();
2349 if (!idStr.isEmpty())
2350 {
2351 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
2352 }
2353 for (const Argument &a : m_tempArgs)
2354 {
2355 tagFile << " <templarg>" << convertToXML(a.type);
2356 if (!a.name.isEmpty())
2357 {
2358 tagFile << " " << convertToXML(a.name);
2359 }
2360 tagFile << "</templarg>\n";
2361 }
2362 for (const auto &ibcd : m_inherits)
2363 {
2364 ClassDef *cd=ibcd.classDef;
2365 if (cd && cd->isLinkable())
2366 {
2367 tagFile << " <base";
2368 if (ibcd.prot==Protection::Protected)
2369 {
2370 tagFile << " protection=\"protected\"";
2371 }
2372 else if (ibcd.prot==Protection::Private)
2373 {
2374 tagFile << " protection=\"private\"";
2375 }
2376 if (ibcd.virt==Specifier::Virtual)
2377 {
2378 tagFile << " virtualness=\"virtual\"";
2379 }
2381 cd->displayName(),ibcd.templSpecifiers);
2382 tagFile << ">" << convertToXML(displayName) << "</base>\n";
2383 }
2384 }
2385 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
2386 {
2387 switch (lde->kind())
2388 {
2389 case LayoutDocEntry::ClassNestedClasses:
2390 {
2391 for (const auto &innerCd : m_innerClasses)
2392 {
2393 if (innerCd->isLinkableInProject() && !innerCd->isImplicitTemplateInstance() &&
2394 protectionLevelVisible(innerCd->protection()) &&
2395 !innerCd->isEmbeddedInOuterScope()
2396 )
2397 {
2398 tagFile << " <class kind=\"" << innerCd->compoundTypeString() <<
2399 "\">" << convertToXML(innerCd->name()) << "</class>\n";
2400 }
2401 }
2402 }
2403 break;
2404 case LayoutDocEntry::MemberDecl:
2405 {
2406 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
2407 if (lmd)
2408 {
2409 MemberList * ml = getMemberList(lmd->type);
2410 if (ml)
2411 {
2412 ml->writeTagFile(tagFile);
2413 }
2414 }
2415 }
2416 break;
2417 case LayoutDocEntry::MemberGroups:
2418 {
2419 for (const auto &mg : m_memberGroups)
2420 {
2421 mg->writeTagFile(tagFile);
2422 }
2423 }
2424 break;
2425 default:
2426 break;
2427 }
2428 }
2429 writeDocAnchorsToTagFile(tagFile);
2430 tagFile << " </compound>\n";
2431}
2432
2433/** Write class documentation inside another container (i.e. a group) */
2435{
2436 bool isSimple = m_isSimple;
2437
2438 ol.addIndexItem(name(),QCString());
2439 //printf("ClassDefImpl::writeInlineDocumentation(%s)\n",qPrint(name()));
2440
2441 // part 1: anchor and title
2442 QCString s = compoundTypeString()+" "+name();
2443
2444 // part 1a
2445 ol.pushGeneratorState();
2447 { // only HTML only
2448 ol.writeAnchor(QCString(),anchor());
2451 ol.parseText(s);
2452 ol.endMemberDocName();
2453 ol.endMemberDoc(FALSE);
2454 ol.writeString("</div>");
2455 ol.startIndent();
2456 }
2457 ol.popGeneratorState();
2458
2459 // part 1b
2460 ol.pushGeneratorState();
2463 { // for LaTeX/RTF only
2465 }
2466 ol.popGeneratorState();
2467
2468 // part 1c
2469 ol.pushGeneratorState();
2471 {
2472 // for LaTeX/RTF/Man
2473 ol.startGroupHeader("",1);
2474 ol.parseText(s);
2475 ol.endGroupHeader(1);
2476 }
2477 ol.popGeneratorState();
2478
2479 SrcLangExt lang=getLanguage();
2480
2481 // part 2: the header and detailed description
2482 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
2483 {
2484 switch (lde->kind())
2485 {
2486 case LayoutDocEntry::BriefDesc:
2487 {
2488 // since we already shown the brief description in the
2489 // declaration part of the container, so we use this to
2490 // show the details on top.
2492 }
2493 break;
2494 case LayoutDocEntry::ClassInheritanceGraph:
2496 break;
2497 case LayoutDocEntry::ClassCollaborationGraph:
2499 break;
2500 case LayoutDocEntry::MemberDeclStart:
2502 break;
2503 case LayoutDocEntry::MemberDecl:
2504 {
2505 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
2506 if (lmd)
2507 {
2508 ClassDefSet visitedClasses;
2509 if (!isSimple) writeMemberDeclarations(ol,visitedClasses,lmd->type,lmd->title(lang),lmd->subtitle(lang),TRUE);
2510 }
2511 }
2512 break;
2513 case LayoutDocEntry::MemberGroups:
2515 break;
2516 case LayoutDocEntry::MemberDeclEnd:
2518 break;
2519 case LayoutDocEntry::MemberDefStart:
2521 break;
2522 case LayoutDocEntry::MemberDef:
2523 {
2524 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
2525 if (lmd)
2526 {
2527 if (isSimple)
2528 {
2530 }
2531 else
2532 {
2533 writeMemberDocumentation(ol,lmd->type,lmd->title(lang),TRUE);
2534 }
2535 }
2536 }
2537 break;
2538 case LayoutDocEntry::MemberDefEnd:
2540 break;
2541 default:
2542 break;
2543 }
2544 }
2545
2546 // part 3: close the block
2547 ol.pushGeneratorState();
2549 { // HTML only
2550 ol.endIndent();
2551 }
2552 ol.popGeneratorState();
2553}
2554
2556{
2557 // TODO: clean up this mess by moving it to
2558 // the output generators...
2559 bool pdfHyperlinks = Config_getBool(PDF_HYPERLINKS);
2560 bool rtfHyperlinks = Config_getBool(RTF_HYPERLINKS);
2561 bool usePDFLatex = Config_getBool(USE_PDFLATEX);
2562
2563 // HTML only
2564 ol.pushGeneratorState();
2566 ol.docify(" ");
2568 anchor.isEmpty() ? QCString("details") : anchor);
2569 ol.parseText(theTranslator->trMore());
2570 ol.endTextLink();
2571 ol.popGeneratorState();
2572
2573 if (!anchor.isEmpty())
2574 {
2575 ol.pushGeneratorState();
2576 // LaTeX + RTF
2580 if (!(usePDFLatex && pdfHyperlinks))
2581 {
2583 }
2584 if (!rtfHyperlinks)
2585 {
2587 }
2588 ol.docify(" ");
2590 ol.parseText(theTranslator->trMore());
2591 ol.endTextLink();
2592 // RTF only
2594 ol.writeString("\\par");
2595 ol.popGeneratorState();
2596 }
2597}
2598
2600{
2601 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
2602 bool hideUndocClasses = Config_getBool(HIDE_UNDOC_CLASSES);
2603 bool extractLocalClasses = Config_getBool(EXTRACT_LOCAL_CLASSES);
2604 bool linkable = isLinkable();
2605 return (!isAnonymous() && !isExtension() &&
2606 (protection()!=Protection::Private || extractPrivate) &&
2607 (linkable || (!hideUndocClasses && (!isLocal() || extractLocalClasses)))
2608 );
2609}
2610
2611void ClassDefImpl::writeDeclarationLink(OutputList &ol,bool &found,const QCString &header,bool localNames) const
2612{
2613 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
2614 //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
2615 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
2616 SrcLangExt lang = getLanguage();
2618 {
2619 if (!found) // first class
2620 {
2621 if (sliceOpt)
2622 {
2623 if (compoundType()==Interface)
2624 {
2625 ol.startMemberHeader("interfaces");
2626 }
2627 else if (compoundType()==Struct)
2628 {
2629 ol.startMemberHeader("structs");
2630 }
2631 else if (compoundType()==Exception)
2632 {
2633 ol.startMemberHeader("exceptions");
2634 }
2635 else // compoundType==Class
2636 {
2637 ol.startMemberHeader("nested-classes");
2638 }
2639 }
2640 else // non-Slice optimization: single header for class/struct/..
2641 {
2642 ol.startMemberHeader("nested-classes");
2643 }
2644 if (!header.isEmpty())
2645 {
2646 ol.parseText(header);
2647 }
2648 else if (lang==SrcLangExt::VHDL)
2649 {
2651 }
2652 else
2653 {
2654 ol.parseText(lang==SrcLangExt::Fortran ?
2655 theTranslator->trDataTypes() :
2656 theTranslator->trCompounds());
2657 }
2658 ol.endMemberHeader();
2659 ol.startMemberList();
2660 found=TRUE;
2661 }
2663 QCString ctype = compoundTypeString();
2664 QCString cname = displayName(!localNames);
2665 QCString anc = anchor();
2666 if (anc.isEmpty()) anc = cname; else anc.prepend(cname+"_");
2668
2669 if (lang!=SrcLangExt::VHDL) // for VHDL we swap the name and the type
2670 {
2671 if (isSliceLocal())
2672 {
2673 ol.writeString("local ");
2674 }
2675 ol.writeString(ctype);
2676 ol.writeString(" ");
2677 ol.insertMemberAlign();
2678 }
2679 if (isLinkable())
2680 {
2683 anchor(),
2684 cname
2685 );
2686 }
2687 else
2688 {
2689 ol.startBold();
2690 ol.docify(cname);
2691 ol.endBold();
2692 }
2693 if (lang==SrcLangExt::VHDL) // now write the type
2694 {
2695 ol.writeString(" ");
2696 ol.insertMemberAlign();
2698 }
2700
2701 // add the brief description if available
2702 if (!briefDescription().isEmpty() && Config_getBool(BRIEF_MEMBER_DESC))
2703 {
2704 auto parser { createDocParser() };
2705 auto ast { validatingParseDoc(*parser.get(),
2706 briefFile(),
2707 briefLine(),
2708 this,
2709 nullptr,
2711 DocOptions()
2712 .setSingleLine(true))
2713 };
2714 if (!ast->isEmpty())
2715 {
2717 ol.writeDoc(ast.get(),this,nullptr);
2718 if (isLinkableInProject())
2719 {
2720 writeMoreLink(ol,anchor());
2721 }
2723 }
2724 }
2726 }
2727}
2728
2730{
2731 StringVector sl;
2732 if (isFinal()) sl.emplace_back("final");
2733 if (isSealed()) sl.emplace_back("sealed");
2734 if (isAbstract()) sl.emplace_back("abstract");
2735 if (isExported()) sl.emplace_back("export");
2736 if (getLanguage()==SrcLangExt::IDL && isPublished()) sl.emplace_back("published");
2737
2738 for (const auto &sx : m_qualifiers)
2739 {
2740 bool alreadyAdded = std::find(sl.begin(), sl.end(), sx) != sl.end();
2741 if (!alreadyAdded)
2742 {
2743 sl.push_back(sx);
2744 }
2745 }
2746
2747 ol.pushGeneratorState();
2749 if (!sl.empty())
2750 {
2751 ol.startLabels();
2752 size_t i=0;
2753 for (const auto &s : sl)
2754 {
2755 i++;
2756 ol.writeLabel(s,i==sl.size());
2757 }
2758 ol.endLabels();
2759 }
2760 ol.popGeneratorState();
2761}
2762
2764{
2765 ol.startContents();
2766
2767 QCString pageType = " ";
2768 pageType += compoundTypeString();
2769
2770 bool exampleFlag=hasExamples();
2771
2772 //---------------------------------------- start flexible part -------------------------------
2773
2774 SrcLangExt lang = getLanguage();
2775
2776 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
2777 {
2778 switch (lde->kind())
2779 {
2780 case LayoutDocEntry::BriefDesc:
2781 writeBriefDescription(ol,exampleFlag);
2782 break;
2783 case LayoutDocEntry::ClassIncludes:
2784 if (lang==SrcLangExt::Slice)
2785 {
2787 }
2788 else
2789 {
2791 }
2792 break;
2793 case LayoutDocEntry::ClassInheritanceGraph:
2795 break;
2796 case LayoutDocEntry::ClassCollaborationGraph:
2798 break;
2799 case LayoutDocEntry::ClassAllMembersLink:
2800 //writeAllMembersLink(ol); // this is now part of the summary links
2801 break;
2802 case LayoutDocEntry::MemberDeclStart:
2804 break;
2805 case LayoutDocEntry::MemberGroups:
2807 break;
2808 case LayoutDocEntry::MemberDecl:
2809 {
2810 ClassDefSet visitedClasses;
2811 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
2812 if (lmd)
2813 {
2814 writeMemberDeclarations(ol,visitedClasses,lmd->type,lmd->title(lang),lmd->subtitle(lang));
2815 }
2816 }
2817 break;
2818 case LayoutDocEntry::ClassNestedClasses:
2819 {
2820 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
2821 if (ls)
2822 {
2823 writeNestedClasses(ol,ls->title(lang));
2824 }
2825 }
2826 break;
2827 case LayoutDocEntry::MemberDeclEnd:
2829 break;
2830 case LayoutDocEntry::DetailedDesc:
2831 {
2832 const LayoutDocEntrySection *ls = dynamic_cast<const LayoutDocEntrySection*>(lde.get());
2833 if (ls)
2834 {
2835 writeDetailedDescription(ol,pageType,exampleFlag,ls->title(lang));
2836 }
2837 }
2838 break;
2839 case LayoutDocEntry::MemberDefStart:
2841 break;
2842 case LayoutDocEntry::ClassInlineClasses:
2844 break;
2845 case LayoutDocEntry::MemberDef:
2846 {
2847 const LayoutDocEntryMemberDef *lmd = dynamic_cast<const LayoutDocEntryMemberDef*>(lde.get());
2848 if (lmd)
2849 {
2850 writeMemberDocumentation(ol,lmd->type,lmd->title(lang));
2851 }
2852 }
2853 break;
2854 case LayoutDocEntry::MemberDefEnd:
2856 break;
2857 case LayoutDocEntry::ClassUsedFiles:
2858 showUsedFiles(ol);
2859 break;
2860 case LayoutDocEntry::AuthorSection:
2862 break;
2863 case LayoutDocEntry::NamespaceNestedNamespaces:
2864 case LayoutDocEntry::NamespaceNestedConstantGroups:
2865 case LayoutDocEntry::NamespaceClasses:
2866 case LayoutDocEntry::NamespaceConcepts:
2867 case LayoutDocEntry::NamespaceInterfaces:
2868 case LayoutDocEntry::NamespaceStructs:
2869 case LayoutDocEntry::NamespaceExceptions:
2870 case LayoutDocEntry::NamespaceInlineClasses:
2871 case LayoutDocEntry::ConceptDefinition:
2872 case LayoutDocEntry::FileClasses:
2873 case LayoutDocEntry::FileConcepts:
2874 case LayoutDocEntry::FileInterfaces:
2875 case LayoutDocEntry::FileStructs:
2876 case LayoutDocEntry::FileExceptions:
2877 case LayoutDocEntry::FileNamespaces:
2878 case LayoutDocEntry::FileConstantGroups:
2879 case LayoutDocEntry::FileIncludes:
2880 case LayoutDocEntry::FileIncludeGraph:
2881 case LayoutDocEntry::FileIncludedByGraph:
2882 case LayoutDocEntry::FileSourceLink:
2883 case LayoutDocEntry::FileInlineClasses:
2884 case LayoutDocEntry::GroupClasses:
2885 case LayoutDocEntry::GroupConcepts:
2886 case LayoutDocEntry::GroupModules:
2887 case LayoutDocEntry::GroupInlineClasses:
2888 case LayoutDocEntry::GroupNamespaces:
2889 case LayoutDocEntry::GroupDirs:
2890 case LayoutDocEntry::GroupNestedGroups:
2891 case LayoutDocEntry::GroupFiles:
2892 case LayoutDocEntry::GroupGraph:
2893 case LayoutDocEntry::GroupPageDocs:
2894 case LayoutDocEntry::ModuleExports:
2895 case LayoutDocEntry::ModuleClasses:
2896 case LayoutDocEntry::ModuleConcepts:
2897 case LayoutDocEntry::ModuleUsedFiles:
2898 case LayoutDocEntry::DirSubDirs:
2899 case LayoutDocEntry::DirFiles:
2900 case LayoutDocEntry::DirGraph:
2901 err("Internal inconsistency: member '{}' should not be part of LayoutDocManager::Class entry list\n",lde->entryToString());
2902 break;
2903 }
2904 }
2905
2906 ol.endContents();
2907}
2908
2910{
2911 QCString pageTitle;
2912 SrcLangExt lang = getLanguage();
2913
2914 auto getReferenceTitle = [this](std::function<QCString()> translateFunc) -> QCString
2915 {
2916 return Config_getBool(HIDE_COMPOUND_REFERENCE) ? displayName() : translateFunc();
2917 };
2918
2919 if (lang==SrcLangExt::Fortran)
2920 {
2921 pageTitle = getReferenceTitle([this](){
2922 return theTranslator->trCompoundReferenceFortran(displayName(), m_compType, !m_tempArgs.empty());
2923 });
2924 }
2925 else if (lang==SrcLangExt::Slice)
2926 {
2927 pageTitle = getReferenceTitle([this](){
2928 return theTranslator->trCompoundReferenceSlice(displayName(), m_compType, isSliceLocal());
2929 });
2930 }
2931 else if (lang==SrcLangExt::VHDL)
2932 {
2933 pageTitle = getReferenceTitle([this](){
2934 return theTranslator->trCustomReference(VhdlDocGen::getClassTitle(this));
2935 });
2936 }
2937 else if (isJavaEnum())
2938 {
2939 pageTitle = getReferenceTitle([this](){
2940 return theTranslator->trEnumReference(displayName());
2941 });
2942 }
2943 else if (m_compType==Service)
2944 {
2945 pageTitle = getReferenceTitle([this](){
2946 return theTranslator->trServiceReference(displayName());
2947 });
2948 }
2949 else if (m_compType==Singleton)
2950 {
2951 pageTitle = getReferenceTitle([this](){
2952 return theTranslator->trSingletonReference(displayName());
2953 });
2954 }
2955 else
2956 {
2957 pageTitle = getReferenceTitle([this](){
2958 return theTranslator->trCompoundReference(displayName(),
2959 m_compType == Interface && getLanguage()==SrcLangExt::ObjC ? Class : m_compType,
2960 !m_tempArgs.empty());
2961 });
2962 }
2963 return pageTitle;
2964}
2965
2966// write all documentation for this class
2968{
2969 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
2970 //bool fortranOpt = Config_getBool(OPTIMIZE_FOR_FORTRAN);
2971 //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
2972 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
2973 QCString pageTitle = title();
2974
2976 if (sliceOpt)
2977 {
2978 if (compoundType()==Interface)
2979 {
2981 }
2982 else if (compoundType()==Struct)
2983 {
2985 }
2986 else if (compoundType()==Exception)
2987 {
2989 }
2990 else
2991 {
2993 }
2994 }
2995 else
2996 {
2998 }
2999
3000 AUTO_TRACE("name='{}' getOutputFileBase='{}'",name(),getOutputFileBase());
3001 bool hasAllMembersLink=false;
3002 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
3003 {
3004 if (lde->kind()==LayoutDocEntry::ClassAllMembersLink)
3005 {
3006 hasAllMembersLink = true;
3007 break;
3008 }
3009 }
3010 QCString memListFile;
3011 if (hasAllMembersLink && !m_allMemberNameInfoLinkedMap.empty() && !Config_getBool(OPTIMIZE_OUTPUT_FOR_C))
3012 {
3013 memListFile = getMemberListFileName();
3014 }
3015 startFile(ol,getOutputFileBase(),false,name(),pageTitle,hli,!generateTreeView,QCString(),0,memListFile);
3016 if (!generateTreeView)
3017 {
3019 {
3021 }
3022 ol.endQuickIndices();
3023 }
3024
3025 startTitle(ol,getOutputFileBase(),this);
3026 ol.parseText(pageTitle);
3028 addGroupListToTitle(ol,this);
3030 writeDocumentationContents(ol,pageTitle);
3031
3032 endFileWithNavPath(ol,this);
3033
3034 if (Config_getBool(SEPARATE_MEMBER_PAGES))
3035 {
3036 writeMemberPages(ol);
3037 }
3038}
3039
3041{
3042 ///////////////////////////////////////////////////////////////////////////
3043 //// Member definitions on separate pages
3044 ///////////////////////////////////////////////////////////////////////////
3045
3046 ol.pushGeneratorState();
3048
3049 for (const auto &ml : m_memberLists)
3050 {
3051 if (ml->numDocMembers()>ml->numDocEnumValues() && ml->listType().isDetailed())
3052 {
3053 ml->writeDocumentationPage(ol,displayName(),this);
3054 }
3055 }
3056
3057 ol.popGeneratorState();
3058}
3059
3061{
3062 bool createSubDirs=Config_getBool(CREATE_SUBDIRS);
3063
3064 ol.writeString(" <div class=\"navtab\">\n");
3065 ol.writeString(" <table>\n");
3066
3067 for (auto &mni : m_allMemberNameInfoLinkedMap)
3068 {
3069 for (auto &mi : *mni)
3070 {
3071 const MemberDef *md=mi->memberDef();
3072 if (md->getClassDef()==this && md->isLinkable() && !md->isEnumValue())
3073 {
3074 if (md->isLinkableInProject())
3075 {
3076 if (md==currentMd) // selected item => highlight
3077 {
3078 ol.writeString(" <tr><td class=\"navtabHL\">");
3079 }
3080 else
3081 {
3082 ol.writeString(" <tr><td class=\"navtab\">");
3083 }
3084 ol.writeString("<span class=\"label\"><a ");
3085 ol.writeString("href=\"");
3086 if (createSubDirs) ol.writeString("../../");
3087 QCString url = md->getOutputFileBase();
3089 ol.writeString(url+"#"+md->anchor());
3090 ol.writeString("\">");
3091 ol.writeString(convertToHtml(md->name()));
3092 ol.writeString("</a></span>");
3093 ol.writeString("</td></tr>\n");
3094 }
3095 }
3096 }
3097 }
3098
3099 ol.writeString(" </table>\n");
3100 ol.writeString(" </div>\n");
3101}
3102
3103
3104
3106{
3107 // write inner classes after the parent, so the tag files contain
3108 // the definition in proper order!
3109 for (const auto &innerCd : m_innerClasses)
3110 {
3111 if (
3112 innerCd->isLinkableInProject() && !innerCd->isImplicitTemplateInstance() &&
3113 protectionLevelVisible(innerCd->protection()) &&
3114 !innerCd->isEmbeddedInOuterScope()
3115 )
3116 {
3117 msg("Generating docs for nested compound {}...\n",innerCd->displayName());
3118 innerCd->writeDocumentation(ol);
3119 innerCd->writeMemberList(ol);
3120 }
3121 innerCd->writeDocumentationForInnerClasses(ol);
3122 }
3123}
3124
3125// write the list of all (inherited) members for this class
3127{
3128 bool cOpt = Config_getBool(OPTIMIZE_OUTPUT_FOR_C);
3129 //bool vhdlOpt = Config_getBool(OPTIMIZE_OUTPUT_VHDL);
3130 bool sliceOpt = Config_getBool(OPTIMIZE_OUTPUT_SLICE);
3131 bool generateTreeView = Config_getBool(GENERATE_TREEVIEW);
3132 if (m_allMemberNameInfoLinkedMap.empty() || cOpt) return;
3133 // only for HTML
3134 ol.pushGeneratorState();
3136
3138 if (sliceOpt)
3139 {
3140 if (compoundType()==Interface)
3141 {
3143 }
3144 else if (compoundType()==Struct)
3145 {
3147 }
3148 else if (compoundType()==Exception)
3149 {
3151 }
3152 else
3153 {
3155 }
3156 }
3157 else
3158 {
3160 }
3161
3162 QCString memListFile = getMemberListFileName();
3163 startFile(ol,memListFile,false,memListFile,theTranslator->trMemberList(),hli,!generateTreeView,getOutputFileBase());
3164 if (!generateTreeView)
3165 {
3167 {
3169 }
3170 ol.endQuickIndices();
3171 }
3172 startTitle(ol,QCString());
3173 ol.parseText(displayName()+" "+theTranslator->trMemberList());
3174 endTitle(ol,QCString(),QCString());
3175 ol.startContents();
3176 ol.startParagraph();
3177 ol.parseText(theTranslator->trThisIsTheListOfAllMembers());
3178 ol.docify(" ");
3180 ol.parseText(theTranslator->trIncludingInheritedMembers());
3181 ol.endParagraph();
3182
3183 //ol.startItemList();
3184
3185 bool first = true; // to prevent empty table
3186 int idx=0;
3187 for (auto &mni : m_allMemberNameInfoLinkedMap)
3188 {
3189 for (auto &mi : *mni)
3190 {
3191 const MemberDef *md=mi->memberDef();
3192 const ClassDef *cd=md->getClassDef();
3193 Protection prot = mi->prot();
3194 Specifier virt=md->virtualness();
3195
3196 //printf("%s: Member %s of class %s md->protection()=%d mi->prot=%d prot=%d inherited=%d\n",
3197 // qPrint(name()),qPrint(md->name()),qPrint(cd->name()),md->protection(),mi->prot,prot,mi->inherited);
3198
3199 if (cd && !md->name().isEmpty() && !md->isAnonymous())
3200 {
3201 bool memberWritten=FALSE;
3202 if (cd->isLinkable() && md->isLinkable())
3203 // create a link to the documentation
3204 {
3205 QCString name=mi->ambiguityResolutionScope()+md->name();
3206 //ol.writeListItem();
3207 if (first)
3208 {
3209 ol.writeString("<table class=\"directory\">\n");
3210 first = false;
3211 }
3212 ol.writeString(" <tr");
3213 if ((idx&1)==0) ol.writeString(" class=\"even\""); else ol.writeString(" class=\"odd\"");
3214 idx++;
3215 ol.writeString("><td class=\"entry\">");
3216 if (cd->isObjectiveC())
3217 {
3218 if (md->isObjCMethod())
3219 {
3220 if (md->isStatic())
3221 ol.writeString("+&#160;</td><td>");
3222 else
3223 ol.writeString("-&#160;</td><td>");
3224 }
3225 else
3226 ol.writeString("</td><td class=\"entry\">");
3227 }
3228 if (md->isObjCMethod())
3229 {
3231 md->getOutputFileBase(),
3232 md->anchor(),md->name());
3233 }
3234 else
3235 {
3236 //Definition *bd = md->getGroupDef();
3237 //if (bd==nullptr) bd=cd;
3239 md->getOutputFileBase(),
3240 md->anchor(),name);
3241
3242 if ( md->isFunction() || md->isSignal() || md->isSlot() ||
3243 (md->isFriend() && !md->argsString().isEmpty()))
3244 ol.docify(md->argsString());
3245 else if (md->isEnumerate())
3246 ol.parseText(" "+theTranslator->trEnumName());
3247 else if (md->isEnumValue())
3248 ol.parseText(" "+theTranslator->trEnumValue());
3249 else if (md->isTypedef())
3250 ol.docify(" typedef");
3251 else if (md->isFriend() && md->typeString()=="friend class")
3252 ol.docify(" class");
3253 //ol.writeString("\n");
3254 }
3255 ol.writeString("</td>");
3256 memberWritten=TRUE;
3257 }
3258 else if (!cd->isArtificial() &&
3259 !Config_getBool(HIDE_UNDOC_MEMBERS) &&
3261 ) // no documentation,
3262 // generate link to the class instead.
3263 {
3264 //ol.writeListItem();
3265 if (first)
3266 {
3267 ol.writeString("<table class=\"directory\">\n");
3268 first = false;
3269 }
3270 ol.writeString(" <tr bgcolor=\"#f0f0f0\"");
3271 if ((idx&1)==0) ol.writeString(" class=\"even\""); else ol.writeString(" class=\"odd\"");
3272 idx++;
3273 ol.writeString("><td class=\"entry\">");
3274 if (cd->isObjectiveC())
3275 {
3276 if (md->isObjCMethod())
3277 {
3278 if (md->isStatic())
3279 ol.writeString("+&#160;</td><td class=\"entry\">");
3280 else
3281 ol.writeString("-&#160;</td><td class=\"entry\">");
3282 }
3283 else
3284 ol.writeString("</td><td class=\"entry\">");
3285 }
3286 ol.startBold();
3287 ol.docify(md->name());
3288 ol.endBold();
3289 if (!md->isObjCMethod())
3290 {
3291 if ( md->isFunction() || md->isSignal() || md->isSlot() )
3292 ol.docify(md->argsString());
3293 else if (md->isEnumerate())
3294 ol.parseText(" "+theTranslator->trEnumName());
3295 else if (md->isEnumValue())
3296 ol.parseText(" "+theTranslator->trEnumValue());
3297 else if (md->isTypedef())
3298 ol.docify(" typedef");
3299 }
3300 ol.writeString(" (");
3301 ol.parseText(theTranslator->trDefinedIn()+" ");
3302 if (cd->isLinkable())
3303 {
3304 ol.writeObjectLink(
3305 cd->getReference(),
3306 cd->getOutputFileBase(),
3307 cd->anchor(),
3308 cd->displayName());
3309 }
3310 else
3311 {
3312 ol.startBold();
3313 ol.docify(cd->displayName());
3314 ol.endBold();
3315 }
3316 ol.writeString(")");
3317 ol.writeString("</td>");
3318 memberWritten=TRUE;
3319 }
3320 if (memberWritten)
3321 {
3322 ol.writeString("<td class=\"entry\">");
3324 cd->getOutputFileBase(),
3325 cd->anchor(),
3326 md->category() ?
3327 md->category()->displayName() :
3328 cd->displayName());
3329 ol.writeString("</td>");
3330 ol.writeString("<td class=\"entry\">");
3331 }
3332 SrcLangExt lang = md->getLanguage();
3333 if (
3334 (prot!=Protection::Public || (virt!=Specifier::Normal && getLanguage()!=SrcLangExt::ObjC) ||
3335 md->isFriend() || md->isRelated() || md->isExplicit() ||
3336 md->isMutable() || (md->isInline() && Config_getBool(INLINE_INFO)) ||
3337 md->isSignal() || md->isSlot() || md->isThreadLocal() ||
3338 (getLanguage()==SrcLangExt::IDL &&
3339 (md->isOptional() || md->isAttribute() || md->isUNOProperty())) ||
3340 md->isStatic() || lang==SrcLangExt::VHDL
3341 )
3342 && memberWritten)
3343 {
3344 StringVector sl;
3345 if (lang==SrcLangExt::VHDL)
3346 {
3347 sl.push_back(theTranslator->trVhdlType(md->getVhdlSpecifiers(),TRUE).str()); //append vhdl type
3348 }
3349 else if (md->isFriend()) sl.emplace_back("friend");
3350 else if (md->isRelated()) sl.emplace_back("related");
3351 else
3352 {
3353 if (Config_getBool(INLINE_INFO) && md->isInline())
3354 sl.emplace_back("inline");
3355 if (md->isExplicit()) sl.emplace_back("explicit");
3356 if (md->isMutable()) sl.emplace_back("mutable");
3357 if (md->isThreadLocal()) sl.emplace_back("thread_local");
3358 if (prot==Protection::Protected) sl.emplace_back("protected");
3359 else if (prot==Protection::Private) sl.emplace_back("private");
3360 else if (prot==Protection::Package) sl.emplace_back("package");
3361 if (virt==Specifier::Virtual && getLanguage()!=SrcLangExt::ObjC)
3362 sl.emplace_back("virtual");
3363 else if (virt==Specifier::Pure) sl.emplace_back("pure virtual");
3364 if (md->isStatic()) sl.emplace_back("static");
3365 if (md->isSignal()) sl.emplace_back("signal");
3366 if (md->isSlot()) sl.emplace_back("slot");
3367// this is the extra member page
3368 if (md->isOptional()) sl.emplace_back("optional");
3369 if (md->isAttribute()) sl.emplace_back("attribute");
3370 if (md->isUNOProperty()) sl.emplace_back("property");
3371 if (md->isReadonly()) sl.emplace_back("readonly");
3372 if (md->isBound()) sl.emplace_back("bound");
3373 if (md->isRemovable()) sl.emplace_back("removable");
3374 if (md->isConstrained()) sl.emplace_back("constrained");
3375 if (md->isTransient()) sl.emplace_back("transient");
3376 if (md->isMaybeVoid()) sl.emplace_back("maybevoid");
3377 if (md->isMaybeDefault()) sl.emplace_back("maybedefault");
3378 if (md->isMaybeAmbiguous()) sl.emplace_back("maybeambiguous");
3379 }
3380 bool firstSpan=true;
3381 for (const auto &s : sl)
3382 {
3383 if (!firstSpan)
3384 {
3385 ol.writeString("</span><span class=\"mlabel\">");
3386 }
3387 else
3388 {
3389 ol.writeString("<span class=\"mlabel\">");
3390 firstSpan=false;
3391 }
3392 ol.docify(s);
3393 }
3394 if (!firstSpan) ol.writeString("</span>");
3395 }
3396 if (memberWritten)
3397 {
3398 ol.writeString("</td>");
3399 ol.writeString("</tr>\n");
3400 }
3401 }
3402 }
3403 }
3404 //ol.endItemList();
3405
3406 if (!first) ol.writeString("</table>");
3407
3408 endFile(ol);
3409 ol.popGeneratorState();
3410}
3411
3412// add a reference to an example
3413bool ClassDefImpl::addExample(const QCString &anchor,const QCString &nameStr, const QCString &file)
3414{
3415 return m_examples.inSort(Example(anchor,nameStr,file));
3416}
3417
3418// returns TRUE if this class is used in an example
3420{
3421 return !m_examples.empty();
3422}
3423
3424void ClassDefImpl::addTypeConstraint(const QCString &typeConstraint,const QCString &type)
3425{
3426 //printf("addTypeConstraint(%s,%s)\n",qPrint(type),qPrint(typeConstraint));
3427 bool hideUndocRelation = Config_getBool(HIDE_UNDOC_RELATIONS);
3428 if (typeConstraint.isEmpty() || type.isEmpty()) return;
3429 SymbolResolver resolver(getFileDef());
3430 ClassDefMutable *cd = resolver.resolveClassMutable(this,typeConstraint);
3431 if (cd==nullptr && !hideUndocRelation)
3432 {
3433 cd = toClassDefMutable(
3434 Doxygen::hiddenClassLinkedMap->add(typeConstraint,
3435 std::unique_ptr<ClassDef>(
3436 new ClassDefImpl(
3438 getDefColumn(),
3439 typeConstraint,
3440 ClassDef::Class))));
3441 if (cd)
3442 {
3443 cd->setUsedOnly(TRUE);
3444 cd->setLanguage(getLanguage());
3445 //printf("Adding undocumented constraint '%s' to class %s on type %s\n",
3446 // qPrint(typeConstraint),qPrint(name()),qPrint(type));
3447 }
3448 }
3449 if (cd)
3450 {
3451 auto it = std::find_if(m_constraintClassList.begin(),
3453 [&cd](const auto &ccd) { return ccd.classDef==cd; });
3454
3455 if (it==m_constraintClassList.end())
3456 {
3457 m_constraintClassList.emplace_back(cd);
3458 it = m_constraintClassList.end()-1;
3459 }
3460 (*it).addAccessor(type);
3461 //printf("Adding constraint '%s' to class %s on type %s\n",
3462 // qPrint(typeConstraint),qPrint(name()),qPrint(type));
3463 }
3464}
3465
3466// Java Type Constrains: A<T extends C & I>
3468{
3469 for (const Argument &a : m_tempArgs)
3470 {
3471 if (!a.typeConstraint.isEmpty())
3472 {
3473 QCString typeConstraint;
3474 int i=0,p=0;
3475 while ((i=a.typeConstraint.find('&',p))!=-1) // typeConstraint="A &I" for C<T extends A & I>
3476 {
3477 typeConstraint = a.typeConstraint.mid(p,i-p).stripWhiteSpace();
3478 addTypeConstraint(typeConstraint,a.type);
3479 p=i+1;
3480 }
3481 typeConstraint = a.typeConstraint.right(a.typeConstraint.length()-p).stripWhiteSpace();
3482 addTypeConstraint(typeConstraint,a.type);
3483 }
3484 }
3485}
3486
3487// C# Type Constraints: D<T> where T : C, I
3492
3494{
3495 m_tempArgs = al;
3496}
3497
3498static bool hasNonReferenceSuperClassRec(const ClassDef *cd,int level)
3499{
3500 bool found=!cd->isReference() && cd->isLinkableInProject() && !cd->isHidden();
3501 if (found)
3502 {
3503 return TRUE; // we're done if this class is not a reference
3504 }
3505 for (const auto &ibcd : cd->subClasses())
3506 {
3507 const ClassDef *bcd=ibcd.classDef;
3508 if (level>256)
3509 {
3510 err("Possible recursive class relation while inside {} and looking for base class {}\n",cd->name(),bcd->name());
3511 return FALSE;
3512 }
3513 // recurse into the super class branch
3514 found = found || hasNonReferenceSuperClassRec(bcd,level+1);
3515 if (!found)
3516 {
3517 // look for template instances that might have non-reference super classes
3518 for (const auto &cil : bcd->getTemplateInstances())
3519 {
3520 // recurse into the template instance branch
3521 found = hasNonReferenceSuperClassRec(cil.classDef,level+1);
3522 if (found) break;
3523 }
3524 }
3525 else
3526 {
3527 break;
3528 }
3529 }
3530 return found;
3531}
3532
3533/*! Returns \c TRUE iff this class or a class inheriting from this class
3534 * is \e not defined in an external tag file.
3535 */
3537{
3538 return hasNonReferenceSuperClassRec(this,0);
3539}
3540
3545
3547{
3548 m_requiresClause = req;
3549}
3550
3551/*! called from MemberDef::writeDeclaration() to (recursively) write the
3552 * definition of an anonymous struct, union or class.
3553 */
3554void ClassDefImpl::writeDeclaration(OutputList &ol,const MemberDef *md,bool inGroup,int indentLevel,
3555 const ClassDef *inheritedFrom,const QCString &inheritId) const
3556{
3557 //printf("ClassName='%s' inGroup=%d\n",qPrint(name()),inGroup);
3558
3561 if (!cn.isEmpty())
3562 {
3563 ol.docify(" ");
3564 if (md && isLinkable())
3565 {
3566 ol.writeObjectLink(QCString(),QCString(),md->anchor(),cn);
3567 }
3568 else
3569 {
3570 ol.startBold();
3571 ol.docify(cn);
3572 ol.endBold();
3573 }
3574 }
3575 ol.docify(" {");
3577 ol.endMemberDeclaration(md ? md->anchor() : QCString(),inheritId);
3578
3579 // write user defined member groups
3580 for (const auto &mg : m_memberGroups)
3581 {
3582 mg->writePlainDeclarations(ol,inGroup,this,nullptr,nullptr,nullptr,nullptr,indentLevel,inheritedFrom,inheritId);
3583 }
3584
3585 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
3586 {
3587 if (lde->kind()==LayoutDocEntry::MemberDecl)
3588 {
3589 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
3590 if (lmd)
3591 {
3592 writePlainMemberDeclaration(ol,lmd->type,inGroup,indentLevel,inheritedFrom,inheritId);
3593 }
3594 }
3595 }
3596}
3597
3598/*! a link to this class is possible within this project */
3600{
3601 bool extractLocal = Config_getBool(EXTRACT_LOCAL_CLASSES);
3602 bool extractStatic = Config_getBool(EXTRACT_STATIC);
3603 bool hideUndoc = Config_getBool(HIDE_UNDOC_CLASSES);
3605 {
3606 return m_templateMaster->isLinkableInProject();
3607 }
3608 else
3609 {
3610 //printf("%s::isLinkableInProject() conditions: artificial=%d hidden=%d anonymous=%d protection=%d local=%d docs=%d static=%d ref=%d\n",
3611 // qPrint(name()),
3612 // !isArtificial(),
3613 // !isHidden(),
3614 // !isAnonymous(),
3615 // m_prot,
3616 // !m_isLocal || extractLocal,
3617 // hasDocumentation() || m_tempArgs.hasTemplateDocumentation() || !hideUndoc,
3618 // !m_isStatic || extractStatic,
3619 // !isReference());
3620 return
3621 !isArtificial() && !isHidden() && /* not hidden */
3622 !isAnonymous() && /* not anonymous */
3623 protectionLevelVisible(m_prot) && /* private/internal */
3624 (!m_isLocal || extractLocal) && /* local */
3625 (hasDocumentation() || m_tempArgs.hasTemplateDocumentation() || !hideUndoc) && /* documented */
3626 (!m_isStatic || extractStatic) && /* static */
3627 !isReference(); /* not an external reference */
3628 }
3629}
3630
3632{
3634 {
3635 return m_templateMaster->isLinkable();
3636 }
3637 else
3638 {
3639 return isReference() || isLinkableInProject();
3640 }
3641}
3642
3643
3644/*! the class is visible in a class diagram, or class hierarchy */
3646{
3647 bool allExternals = Config_getBool(ALLEXTERNALS);
3648 bool hideUndocClasses = Config_getBool(HIDE_UNDOC_CLASSES);
3649 bool extractStatic = Config_getBool(EXTRACT_STATIC);
3650
3651 return // show all classes or a subclass is visible
3652 ((allExternals && !isArtificial()) || hasNonReferenceSuperClass()) &&
3653 // and not an anonymous compound
3654 !isAnonymous() &&
3655 // and not privately inherited
3657 // documented or shown anyway or documentation is external
3658 (hasDocumentation() ||
3659 !hideUndocClasses ||
3660 (m_templateMaster && m_templateMaster->hasDocumentation()) ||
3661 isReference()
3662 ) &&
3663 // if this is an implicit template instance then it most be part of the inheritance hierarchy
3664 (!m_implicitTemplateInstance || !m_inherits.empty() || !m_inheritedBy.empty()) &&
3665 // is not part of an unnamed namespace or shown anyway
3666 (!m_isStatic || extractStatic);
3667}
3668
3673
3674//----------------------------------------------------------------------
3675// recursive function:
3676// returns the distance to the base class definition 'bcd' represents an (in)direct base
3677// class of class definition 'cd' or nullptr if it does not.
3678
3679int ClassDefImpl::isBaseClass(const ClassDef *bcd, bool followInstances,const QCString &templSpec) const
3680{
3681 int distance=0;
3682 //printf("isBaseClass(cd=%s) looking for %s templSpec=%s\n",qPrint(name()),qPrint(bcd->name()),qPrint(templSpec));
3683 for (const auto &bclass : baseClasses())
3684 {
3685 const ClassDef *ccd = bclass.classDef;
3686 if (!followInstances && ccd->templateMaster())
3687 {
3688 ccd=ccd->templateMaster();
3689 }
3690 if (ccd==bcd && (templSpec.isEmpty() || templSpec==bclass.templSpecifiers))
3691 {
3692 distance=1;
3693 break; // no shorter path possible
3694 }
3695 else
3696 {
3697 int d = ccd->isBaseClass(bcd,followInstances,templSpec);
3698 if (d>256)
3699 {
3700 err("Possible recursive class relation while inside {} and looking for base class {}\n",name(),bcd->name());
3701 return 0;
3702 }
3703 else if (d>0) // path found
3704 {
3705 if (distance==0 || d+1<distance) // update if no path found yet or shorter path found
3706 {
3707 distance=d+1;
3708 }
3709 }
3710 }
3711 }
3712 return distance;
3713}
3714
3715//----------------------------------------------------------------------
3716
3717bool ClassDefImpl::isSubClass(ClassDef *cd,int level) const
3718{
3719 bool found=FALSE;
3720 if (level>256)
3721 {
3722 err("Possible recursive class relation while inside {} and looking for derived class {}\n",name(),cd->name());
3723 return FALSE;
3724 }
3725 for (const auto &iscd : subClasses())
3726 {
3727 ClassDef *ccd=iscd.classDef;
3728 found = (ccd==cd) || ccd->isSubClass(cd,level+1);
3729 if (found) break;
3730 }
3731 return found;
3732}
3733
3734//----------------------------------------------------------------------------
3735
3736static bool isStandardFunc(const MemberDef *md)
3737{
3738 return md->name()=="operator=" || // assignment operator
3739 md->isConstructor() || // constructor
3740 md->isDestructor(); // destructor
3741}
3742
3743void ClassDefImpl::mergeMembersFromBaseClasses(bool mergeVirtualBaseClass)
3744{
3745 SrcLangExt lang = getLanguage();
3747 size_t sepLen = sep.length();
3748 bool inlineInheritedMembers = Config_getBool(INLINE_INHERITED_MEMB);
3749 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
3750
3751 //printf(" mergeMembers for %s mergeVirtualBaseClass=%d\n",qPrint(name()),mergeVirtualBaseClass);
3752 // the merge the base members with this class' members
3753 for (const auto &bcd : baseClasses())
3754 {
3755 ClassDefMutable *bClass=toClassDefMutable(bcd.classDef);
3756 if (bClass)
3757 {
3758 const MemberNameInfoLinkedMap &srcMnd = bClass->memberNameInfoLinkedMap();
3760
3761 for (auto &srcMni : srcMnd)
3762 {
3763 MemberNameInfo *dstMni=dstMnd.find(srcMni->memberName());
3764 if (dstMni)
3765 // a member with that name is already in the class.
3766 // the member may hide or reimplement the one in the sub class
3767 // or there may be another path to the base class that is already
3768 // visited via another branch in the class hierarchy.
3769 {
3770 //printf(" %s hides member name %s\n",qPrint(bClass->name()),qPrint(srcMni->memberName()));
3771 for (auto &srcMi : *srcMni)
3772 {
3773 MemberDef *srcMd = srcMi->memberDef();
3774 bool found=FALSE;
3775 bool ambiguous=FALSE;
3776 bool hidden=FALSE;
3777 const ClassDef *srcCd = srcMd->getClassDef();
3778 for (auto &dstMi : *dstMni)
3779 {
3780 const MemberDef *dstMd = dstMi->memberDef();
3781 if (srcMd!=dstMd) // different members
3782 {
3783 const ClassDef *dstCd = dstMd->getClassDef();
3784 //printf(" Is %s a base class of %s?\n",qPrint(srcCd->name()),qPrint(dstCd->name()));
3785 if (srcCd==dstCd || dstCd->isBaseClass(srcCd,TRUE))
3786 // member is in the same or a base class
3787 {
3788 const ArgumentList &srcAl = srcMd->argumentList();
3789 const ArgumentList &dstAl = dstMd->argumentList();
3790 found=matchArguments2(
3791 srcMd->getOuterScope(),srcMd->getFileDef(),&srcAl,
3792 dstMd->getOuterScope(),dstMd->getFileDef(),&dstAl,
3793 TRUE,lang
3794 );
3795 //printf(" Yes, matching (%s<->%s): %d\n",
3796 // qPrint(argListToString(srcMd->argumentList())),
3797 // qPrint(argListToString(dstMd->argumentList())),
3798 // found);
3799 hidden = hidden || !found;
3800 }
3801 else // member is in a non base class => multiple inheritance
3802 // using the same base class.
3803 {
3804 //printf(" $$ Existing member %s %s add scope %s\n",
3805 // qPrint(dstMi->ambiguityResolutionScope()),
3806 // qPrint(dstMd->name()),
3807 // qPrint(dstMi->scopePath().left(dstMi->scopePath().find("::")+2)));
3808
3809 QCString scope=dstMi->scopePath().left(dstMi->scopePath().find(sep)+sepLen);
3810 if (scope!=dstMi->ambiguityResolutionScope().left(scope.length()))
3811 {
3812 dstMi->setAmbiguityResolutionScope(scope+dstMi->ambiguityResolutionScope());
3813 }
3814 ambiguous=TRUE;
3815 }
3816 }
3817 else // same members
3818 {
3819 // do not add if base class is virtual or
3820 // if scope paths are equal or
3821 // if base class is an interface (and thus implicitly virtual).
3822 //printf(" same member found srcMi->virt=%d dstMi->virt=%d\n",srcMi->virt(),dstMi->virt());
3823 if ((srcMi->virt()!=Specifier::Normal && dstMi->virt()!=Specifier::Normal) ||
3824 bClass->name()+sep+srcMi->scopePath() == dstMi->scopePath() ||
3826 )
3827 {
3828 found=TRUE;
3829 }
3830 else // member can be reached via multiple paths in the
3831 // inheritance tree
3832 {
3833 //printf(" $$ Existing member %s %s add scope %s\n",
3834 // qPrint(dstMi->ambiguityResolutionScope()),
3835 // qPrint(dstMd->name()),
3836 // qPrint(dstMi->scopePath().left(dstMi->scopePath().find("::")+2)));
3837
3838 QCString scope=dstMi->scopePath().left(dstMi->scopePath().find(sep)+sepLen);
3839 if (scope!=dstMi->ambiguityResolutionScope().left(scope.length()))
3840 {
3841 dstMi->setAmbiguityResolutionScope(dstMi->ambiguityResolutionScope()+scope);
3842 }
3843 ambiguous=TRUE;
3844 }
3845 }
3846 if (found) break;
3847 }
3848 //printf(" member %s::%s hidden %d ambiguous %d srcMi->ambigClass=%p found=%d\n",
3849 // qPrint(srcCd->name()),qPrint(srcMd->name()),hidden,ambiguous,
3850 // (void*)srcMi->ambigClass(),found);
3851
3852 // TODO: fix the case where a member is hidden by inheritance
3853 // of a member with the same name but with another prototype,
3854 // while there is more than one path to the member in the
3855 // base class due to multiple inheritance. In this case
3856 // it seems that the member is not reachable by prefixing a
3857 // scope name either (according to my compiler). Currently,
3858 // this case is shown anyway.
3859 if (!found && srcMd->protection()!=Protection::Private && !srcMd->isFriend() &&
3860 srcMi->virtualBaseClass()==mergeVirtualBaseClass && lang!=SrcLangExt::Python)
3861 {
3862 Protection prot = srcMd->protection();
3863 if (bcd.prot==Protection::Protected && prot==Protection::Public)
3864 {
3865 prot = bcd.prot;
3866 }
3867 else if (bcd.prot==Protection::Private)
3868 {
3869 prot = bcd.prot;
3870 }
3871
3872 if (inlineInheritedMembers)
3873 {
3874 if (!isStandardFunc(srcMd))
3875 {
3876 //printf(" %s::insertMember(%s)\n",qPrint(name()),qPrint(srcMd->name()));
3877 internalInsertMember(srcMd,prot,FALSE);
3878 }
3879 }
3880
3881 Specifier virt=srcMi->virt();
3882 if (virt==Specifier::Normal && bcd.virt!=Specifier::Normal) virt=bcd.virt;
3883 bool virtualBaseClass = bcd.virt!=Specifier::Normal;
3884
3885 auto newMi = std::make_unique<MemberInfo>(srcMd,prot,virt,TRUE,virtualBaseClass);
3886 newMi->setScopePath(bClass->name()+sep+srcMi->scopePath());
3887 if (ambiguous)
3888 {
3889 //printf("$$ New member %s %s add scope %s::\n",
3890 // qPrint(srcMi->ambiguityResolutionScope),
3891 // qPrint(srcMd->name()),
3892 // qPrint(bClass->name()));
3893
3894 QCString scope=bClass->name()+sep;
3895 if (scope!=srcMi->ambiguityResolutionScope().left(scope.length()))
3896 {
3897 newMi->setAmbiguityResolutionScope(scope+srcMi->ambiguityResolutionScope());
3898 }
3899 }
3900 if (hidden)
3901 {
3902 if (srcMi->ambigClass()==nullptr)
3903 {
3904 newMi->setAmbigClass(bClass);
3905 newMi->setAmbiguityResolutionScope(bClass->name()+sep);
3906 }
3907 else
3908 {
3909 newMi->setAmbigClass(srcMi->ambigClass());
3910 newMi->setAmbiguityResolutionScope(srcMi->ambigClass()->name()+sep);
3911 }
3912 }
3913 dstMni->push_back(std::move(newMi));
3914 }
3915 }
3916 }
3917 else // base class has a member that is not in the sub class => copy
3918 {
3919 //printf(" %s adds member name %s\n",qPrint(bClass->name()),qPrint(srcMni->memberName()));
3920 // create a deep copy of the list (only the MemberInfo's will be
3921 // copied, not the actual MemberDef's)
3922 MemberNameInfo *newMni = dstMnd.add(srcMni->memberName());
3923
3924 // copy the member(s) from the base to the sub class
3925 for (auto &mi : *srcMni)
3926 {
3927 if (mi->virtualBaseClass()==mergeVirtualBaseClass && !mi->memberDef()->isFriend()) // don't inherit friends
3928 {
3929 Protection prot = mi->prot();
3930 if (bcd.prot==Protection::Protected)
3931 {
3932 if (prot==Protection::Public) prot=Protection::Protected;
3933 }
3934 else if (bcd.prot==Protection::Private)
3935 {
3936 prot=Protection::Private;
3937 }
3938 Specifier virt=mi->virt();
3939 bool virtualBaseClass = bcd.virt!=Specifier::Normal || mi->virtualBaseClass();
3940 if (virt==Specifier::Normal && bcd.virt!=Specifier::Normal) virt=bcd.virt;
3941 //printf(" %s::%s: [mi.prot=%d, bcd.prot=%d => prot=%d], [mi.virt=%d, bcd.virt=%d => virt=%d] virtualBase=%d\n",
3942 // qPrint(name()),qPrint(mi->memberDef()->name()),
3943 // mi->prot(),bcd.prot,prot,
3944 // mi->virt(),bcd.virt,virt,
3945 // virtualBaseClass
3946 // );
3947
3948 if (prot!=Protection::Private || extractPrivate)
3949 {
3950
3951 if (inlineInheritedMembers)
3952 {
3953 if (!isStandardFunc(mi->memberDef()))
3954 {
3955 //printf(" %s::insertMember '%s'\n",qPrint(name()),qPrint(mi->memberDef()->name()));
3956 internalInsertMember(mi->memberDef(),prot,FALSE);
3957 }
3958 }
3959 //printf("Adding!\n");
3960 std::unique_ptr<MemberInfo> newMi = std::make_unique<MemberInfo>(mi->memberDef(),prot,virt,TRUE,virtualBaseClass);
3961 newMi->setScopePath(bClass->name()+sep+mi->scopePath());
3962 newMi->setAmbigClass(mi->ambigClass());
3963 newMi->setAmbiguityResolutionScope(mi->ambiguityResolutionScope());
3964 newMni->push_back(std::move(newMi));
3965 }
3966 }
3967 }
3968 }
3969 }
3970 }
3971 }
3972}
3973
3974// See issue11260, referring to a variable in a base class will make doxygen
3975// add it as a member to the derived class, but this is not correct for non-private variables
3976// so we correct this here, now we know the inheritance hierarchy
3978{
3979 //printf("hideDerivedVariableInPython()\n");
3980 if (bClass)
3981 {
3982 const MemberNameInfoLinkedMap &srcMnd = bClass->memberNameInfoLinkedMap();
3984
3985 // recurse up the inheritance hierarchy
3986 for (const auto &bcd : bClass->baseClasses())
3987 {
3989 }
3990
3991 for (auto &srcMni : srcMnd) // for each member in a base class
3992 {
3993 //printf(" candidate(%s)\n",qPrint(srcMni->memberName()));
3994 MemberNameInfo *dstMni=dstMnd.find(srcMni->memberName());
3995 if (dstMni) // that is also in this class
3996 {
3998 //printf("%s member in %s and %s\n",qPrint(name()),qPrint(bClass->name()),qPrint(name()));
3999 for (it=dstMni->begin();it!=dstMni->end();)
4000 {
4001 MemberDefMutable *dstMd = toMemberDefMutable((*it)->memberDef());
4002 if (dstMd && dstMd->isVariable() && !dstMd->name().startsWith("__"))
4003 {
4004 //printf(" hiding member %s\n",qPrint(dstMd->name()));
4005 // hide a member variable if it is already defined in a base class, unless
4006 // it is a __private variable
4007 removeMemberFromLists(dstMd);
4008 it = dstMni->erase(it);
4009 }
4010 else
4011 {
4012 ++it;
4013 }
4014 }
4015 if (dstMni->empty()) // if the list has become empty, remove the entry from the dictionary
4016 {
4017 dstMnd.del(srcMni->memberName());
4018 }
4019 }
4020 }
4021 }
4022}
4023
4024/*!
4025 * recursively merges the 'all members' lists of a class base
4026 * with that of this class. Must only be called for classes without
4027 * subclasses!
4028 */
4030{
4031 if (m_membersMerged) return;
4032 if (getLanguage()==SrcLangExt::Python)
4033 {
4034 for (const auto &bcd : baseClasses())
4035 {
4036 ClassDefMutable *bClass=toClassDefMutable(bcd.classDef);
4038 }
4039 }
4040
4041 //printf("> %s::mergeMembers()\n",qPrint(name()));
4042
4044
4045 // first merge the members of the base class recursively
4046 for (const auto &bcd : baseClasses())
4047 {
4048 ClassDefMutable *bClass=toClassDefMutable(bcd.classDef);
4049 if (bClass)
4050 {
4051 // merge the members in the base class of this inheritance branch first
4052 bClass->mergeMembers();
4053 }
4054 }
4055
4056 // first merge the member that are not inherited via a virtual base class
4057 // (as this can end up reimplemented via multiple paths, see #10717 for examples)
4059 // then process the member that are inherited via a virtual base class to add the
4060 // ones that are not reimplemented via any path
4062
4063 //printf("< %s::mergeMembers()\n",qPrint(name()));
4064}
4065
4066//----------------------------------------------------------------------------
4067
4068/*! Merges the members of a Objective-C category into this class.
4069 */
4071{
4072 AUTO_TRACE();
4073 ClassDefMutable *category = toClassDefMutable(cat);
4074 if (category)
4075 {
4076 bool extractLocalMethods = Config_getBool(EXTRACT_LOCAL_METHODS);
4077 bool makePrivate = category->isLocal();
4078 // in case extract local methods is not enabled we don't add the methods
4079 // of the category in case it is defined in the .m file.
4080 if (makePrivate && !extractLocalMethods) return;
4081 bool isExtension = category->isExtension();
4082
4083 category->setCategoryOf(this);
4084 if (isExtension)
4085 {
4086 category->setArtificial(TRUE);
4087
4088 // copy base classes/protocols from extension
4089 for (const auto &bcd : category->baseClasses())
4090 {
4091 insertBaseClass(bcd.classDef,bcd.usedName,bcd.prot,bcd.virt,bcd.templSpecifiers);
4092 // correct bcd.classDef so that they do no longer derive from
4093 // category, but from this class!
4094 BaseClassList scl = bcd.classDef->subClasses();
4095 for (auto &scd : scl)
4096 {
4097 if (scd.classDef==category)
4098 {
4099 scd.classDef=this;
4100 }
4101 }
4102 bcd.classDef->updateSubClasses(scl);
4103 }
4104 }
4105 // make methods private for categories defined in the .m file
4106 //printf("%s::mergeCategory makePrivate=%d\n",qPrint(name()),makePrivate);
4107
4108 const MemberNameInfoLinkedMap &srcMnd = category->memberNameInfoLinkedMap();
4110
4111 for (auto &srcMni : srcMnd)
4112 {
4113 MemberNameInfo *dstMni=dstMnd.find(srcMni->memberName());
4114 if (dstMni) // method is already defined in the class
4115 {
4116 AUTO_TRACE_ADD("Existing member {}",srcMni->memberName());
4117 const auto &dstMi = dstMni->front();
4118 const auto &srcMi = srcMni->front();
4119 if (srcMi && dstMi)
4120 {
4121 MemberDefMutable *smdm = toMemberDefMutable(srcMi->memberDef());
4122 MemberDefMutable *dmdm = toMemberDefMutable(dstMi->memberDef());
4123 if (smdm && dmdm)
4124 {
4126 dmdm->setCategory(category);
4127 dmdm->setCategoryRelation(smdm);
4128 smdm->setCategoryRelation(dmdm);
4129 }
4130 }
4131 }
4132 else // new method name
4133 {
4134 AUTO_TRACE_ADD("New member {}",srcMni->memberName());
4135 // create a deep copy of the list
4136 MemberNameInfo *newMni = dstMnd.add(srcMni->memberName());
4137
4138 // copy the member(s) from the category to this class
4139 for (auto &mi : *srcMni)
4140 {
4141 //printf("Adding '%s'\n",qPrint(mi->memberDef->name()));
4142 Protection prot = mi->prot();
4143 //if (makePrivate) prot = Private;
4144 auto newMd = mi->memberDef()->deepCopy();
4145 if (newMd)
4146 {
4147 auto mmd = toMemberDefMutable(newMd.get());
4148 AUTO_TRACE_ADD("Copying member {}",mmd->name());
4149 mmd->moveTo(this);
4150
4151 auto newMi=std::make_unique<MemberInfo>(newMd.get(),prot,mi->virt(),mi->inherited(),mi->virtualBaseClass());
4152 newMi->setScopePath(mi->scopePath());
4153 newMi->setAmbigClass(mi->ambigClass());
4154 newMi->setAmbiguityResolutionScope(mi->ambiguityResolutionScope());
4155 newMni->push_back(std::move(newMi));
4156
4157 // also add the newly created member to the global members list
4158
4159 QCString name = newMd->name();
4161
4162 mmd->setCategory(category);
4163 mmd->setCategoryRelation(mi->memberDef());
4164 auto miMmd = toMemberDefMutable(mi->memberDef());
4165 if (miMmd) miMmd->setCategoryRelation(newMd.get());
4166
4167 if (makePrivate || isExtension)
4168 {
4169 mmd->makeImplementationDetail();
4170 }
4171 internalInsertMember(newMd.get(),prot,FALSE);
4172 mn->push_back(std::move(newMd));
4173 }
4174 }
4175 }
4176 }
4177 }
4178}
4179
4180//----------------------------------------------------------------------------
4181
4183 Protection prot)
4184{
4185 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
4186 bool umlLook = Config_getBool(UML_LOOK);
4187 if (prot==Protection::Private && !extractPrivate) return;
4188 //printf("%s::addUsedClass(%s,%s)\n",qPrint(name()),qPrint(cd->name()),accessName);
4189
4190 auto it = std::find_if(m_usesImplClassList.begin(),
4191 m_usesImplClassList.end(),
4192 [&cd](const auto &ucd) { return ucd.classDef==cd; });
4193 if (it==m_usesImplClassList.end())
4194 {
4195 m_usesImplClassList.emplace_back(cd);
4196 //printf("Adding used class %s to class %s via accessor %s\n",
4197 // qPrint(cd->name()),qPrint(name()),accessName);
4198 it = m_usesImplClassList.end()-1;
4199 }
4200 QCString acc = accessName;
4201 if (umlLook)
4202 {
4203 switch(prot)
4204 {
4205 case Protection::Public: acc.prepend("+"); break;
4206 case Protection::Private: acc.prepend("-"); break;
4207 case Protection::Protected: acc.prepend("#"); break;
4208 case Protection::Package: acc.prepend("~"); break;
4209 }
4210 }
4211 (*it).addAccessor(acc);
4212}
4213
4215 Protection prot)
4216{
4217 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
4218 bool umlLook = Config_getBool(UML_LOOK);
4219 if (prot==Protection::Private && !extractPrivate) return;
4220 //printf("%s::addUsedByClass(%s,%s)\n",qPrint(name()),qPrint(cd->name()),accessName);
4221 //
4222 auto it = std::find_if(m_usedByImplClassList.begin(),
4224 [&cd](const auto &ucd) { return ucd.classDef==cd; });
4225 if (it==m_usedByImplClassList.end())
4226 {
4227 m_usedByImplClassList.emplace_back(cd);
4228 //printf("Adding used by class %s to class %s\n",
4229 // qPrint(cd->name()),qPrint(name()));
4230 it = m_usedByImplClassList.end()-1;
4231 }
4232 QCString acc = accessName;
4233 if (umlLook)
4234 {
4235 switch(prot)
4236 {
4237 case Protection::Public: acc.prepend("+"); break;
4238 case Protection::Private: acc.prepend("-"); break;
4239 case Protection::Protected: acc.prepend("#"); break;
4240 case Protection::Package: acc.prepend("~"); break;
4241 }
4242 }
4243 (*it).addAccessor(acc);
4244}
4245
4246
4251
4253{
4254 bool inlineGroupedClasses = Config_getBool(INLINE_GROUPED_CLASSES);
4255 bool inlineSimpleClasses = Config_getBool(INLINE_SIMPLE_STRUCTS);
4257 {
4258 Definition *scope=nullptr;
4259 if (inlineGroupedClasses && !partOfGroups().empty())
4260 {
4261 // point to the group that embeds this class
4262 return partOfGroups().front()->getOutputFileBase();
4263 }
4264 else if (inlineSimpleClasses && m_isSimple && !partOfGroups().empty())
4265 {
4266 // point to simple struct inside a group
4267 return partOfGroups().front()->getOutputFileBase();
4268 }
4269 else if (inlineSimpleClasses && m_isSimple && (scope=getOuterScope()))
4270 {
4271 if (scope==Doxygen::globalScope && getFileDef() && getFileDef()->isLinkableInProject()) // simple struct embedded in file
4272 {
4273 return getFileDef()->getOutputFileBase();
4274 }
4275 else if (scope->isLinkableInProject()) // simple struct embedded in other container (namespace/group/class)
4276 {
4277 return getOuterScope()->getOutputFileBase();
4278 }
4279 }
4280 }
4281 AUTO_TRACE("name='{}' m_templateMaster={} m_implicitTemplateInstance={}",name(),(void*)m_templateMaster,m_implicitTemplateInstance);
4283 {
4284 // point to the template of which this class is an instance
4285 return m_templateMaster->getOutputFileBase();
4286 }
4287 return m_fileName;
4288}
4289
4294
4296{
4298 {
4299 return m_templateMaster->getSourceFileBase();
4300 }
4301 else
4302 {
4304 }
4305}
4306
4307void ClassDefImpl::setGroupDefForAllMembers(GroupDef *gd,Grouping::GroupPri_t pri,const QCString &fileName,int startLine,bool hasDocs)
4308{
4309 gd->addClass(this);
4310 //printf("ClassDefImpl::setGroupDefForAllMembers(%s)\n",qPrint(gd->name()));
4311 for (auto &mni : m_allMemberNameInfoLinkedMap)
4312 {
4313 for (auto &mi : *mni)
4314 {
4315 MemberDefMutable *md = toMemberDefMutable(mi->memberDef());
4316 if (md)
4317 {
4318 md->setGroupDef(gd,pri,fileName,startLine,hasDocs);
4319 gd->insertMember(md,TRUE);
4321 if (innerClass) innerClass->setGroupDefForAllMembers(gd,pri,fileName,startLine,hasDocs);
4322 }
4323 }
4324 }
4325}
4326
4328{
4329 //printf("**** %s::addInnerCompound(%s)\n",qPrint(name()),qPrint(d->name()));
4330 if (d->definitionType()==Definition::TypeClass) // only classes can be
4331 // nested in classes.
4332 {
4333 m_innerClasses.add(d->localName(),toClassDef(d));
4334 }
4335}
4336
4338{
4339 return m_innerClasses.find(name);
4340}
4341
4343 int startLine, int startColumn, const QCString &templSpec,bool &freshInstance)
4344{
4345 freshInstance = FALSE;
4346 auto it = std::find_if(m_templateInstances.begin(),
4347 m_templateInstances.end(),
4348 [&templSpec](const auto &ti) { return templSpec==ti.templSpec; });
4349 ClassDefMutable *templateClass=nullptr;
4350 if (it!=m_templateInstances.end())
4351 {
4352 templateClass = toClassDefMutable((*it).classDef);
4353 }
4354 if (templateClass==nullptr)
4355 {
4356 QCString tcname = removeRedundantWhiteSpace(name()+templSpec);
4357 AUTO_TRACE("New template instance class name='{}' templSpec='{}' inside '{}' hidden={}",
4358 name(),templSpec,name(),isHidden());
4359
4360 ClassDef *foundCd = Doxygen::classLinkedMap->find(tcname);
4361 if (foundCd)
4362 {
4363 return foundCd;
4364 }
4365 templateClass =
4367 Doxygen::classLinkedMap->add(tcname,
4368 std::unique_ptr<ClassDef>(
4369 new ClassDefImpl(fileName,startLine,startColumn,tcname,ClassDef::Class))));
4370 if (templateClass)
4371 {
4372 templateClass->setTemplateMaster(this);
4373 ArgumentList tal = *stringToArgumentList(getLanguage(),templSpec);
4374 templateClass->setTemplateArguments(tal);
4375 templateClass->setOuterScope(getOuterScope());
4376 templateClass->setHidden(isHidden());
4377 templateClass->setArtificial(isArtificial());
4378 templateClass->setImplicitTemplateInstance(true);
4379 m_templateInstances.emplace_back(templSpec,templateClass);
4380
4381 // also add nested classes
4382 for (const auto &innerCd : m_innerClasses)
4383 {
4384 QCString innerName = tcname+"::"+innerCd->localName();
4385 ClassDefMutable *innerClass =
4387 Doxygen::classLinkedMap->add(innerName,
4388 std::unique_ptr<ClassDef>(
4389 new ClassDefImpl(fileName,startLine,startColumn,innerName,ClassDef::Class))));
4390 if (innerClass)
4391 {
4392 templateClass->addInnerCompound(innerClass);
4393 innerClass->setOuterScope(templateClass);
4394 innerClass->setHidden(isHidden());
4395 innerClass->setArtificial(TRUE);
4396 innerClass->setImplicitTemplateInstance(true);
4397 }
4398 }
4399 freshInstance=TRUE;
4400 }
4401 }
4402 return templateClass;
4403}
4404
4406{
4407 AUTO_TRACE("this={} cd={} templSpec={}",name(),templateClass->name(),templSpec);
4408 m_templateInstances.emplace_back(templSpec,templateClass);
4409}
4410
4412{
4413 m_templBaseClassNames = templateNames;
4414}
4415
4420
4423 const QCString &templSpec)
4424{
4425 AUTO_TRACE("this={} md={}",name(),md->name());
4426 auto actualArguments_p = stringToArgumentList(getLanguage(),templSpec);
4427 auto imd = md->createTemplateInstanceMember(templateArguments,actualArguments_p);
4428 auto mmd = toMemberDefMutable(imd.get());
4429 mmd->setMemberClass(this);
4430 mmd->setTemplateMaster(md);
4431 mmd->setDocumentation(md->documentation(),md->docFile(),md->docLine());
4432 mmd->setBriefDescription(md->briefDescription(),md->briefFile(),md->briefLine());
4433 mmd->setInbodyDocumentation(md->inbodyDocumentation(),md->inbodyFile(),md->inbodyLine());
4434 mmd->setMemberSpecifiers(md->getMemberSpecifiers());
4435 mmd->setMemberGroupId(md->getMemberGroupId());
4436 mmd->setArtificial(true);
4437 insertMember(imd.get());
4438 //printf("Adding member=%s %s%s to class %s templSpec %s\n",
4439 // imd->typeString(),qPrint(imd->name()),imd->argsString(),
4440 // qPrint(imd->getClassDef()->name()),templSpec);
4441 // insert imd in the list of all members
4442 //printf("Adding member=%s class=%s\n",qPrint(imd->name()),qPrint(name()));
4443 MemberName *mn = Doxygen::memberNameLinkedMap->add(imd->name());
4444 mn->push_back(std::move(imd));
4445}
4446
4448{
4449 AUTO_TRACE("this={} cd={} templSpec={}",name(),cd->name(),templSpec);
4450 //printf("%s::addMembersToTemplateInstance(%s,%s)\n",qPrint(name()),qPrint(cd->name()),templSpec);
4451 for (const auto &mni : cd->memberNameInfoLinkedMap())
4452 {
4453 for (const auto &mi : *mni)
4454 {
4455 const MemberDef *md = mi->memberDef();
4456 if (m_allMemberNameInfoLinkedMap.find(md->name())==nullptr) // only insert the member if not hidden by one with the same name (#11541)
4457 {
4459 }
4460 }
4461 }
4462 // also instantatie members for nested classes
4463 for (const auto &innerCd : cd->getClasses())
4464 {
4465 ClassDefMutable *ncd = toClassDefMutable(m_innerClasses.find(innerCd->localName()));
4466 if (ncd)
4467 {
4468 ncd->addMembersToTemplateInstance(innerCd,cd->templateArguments(),templSpec);
4469 }
4470 }
4471}
4472
4474{
4476 {
4477 return m_templateMaster->getReference();
4478 }
4479 else
4480 {
4482 }
4483}
4484
4486{
4488 {
4489 return m_templateMaster->isReference();
4490 }
4491 else
4492 {
4494 }
4495}
4496
4498{
4499 ArgumentLists result;
4501 while (d && d->definitionType()==Definition::TypeClass)
4502 {
4503 result.insert(result.begin(),toClassDef(d)->templateArguments());
4504 d = d->getOuterScope();
4505 }
4506 if (!templateArguments().empty())
4507 {
4508 result.push_back(templateArguments());
4509 }
4510 return result;
4511}
4512
4514 const ArgumentLists *actualParams,uint32_t *actualParamIndex) const
4515{
4516 return makeQualifiedNameWithTemplateParameters(this,actualParams,actualParamIndex);
4517}
4518
4520{
4521 QCString name = m_className.isEmpty() ? localName() : m_className;
4522 auto lang = getLanguage();
4523 if (lang==SrcLangExt::CSharp)
4524 {
4526 }
4527 return name;
4528}
4529
4534
4536{
4537 SrcLangExt lang = getLanguage();
4538 if (!isLinkableInProject()) return;
4539 //printf("ClassDef(%s)::addListReferences()\n",qPrint(name()));
4540 {
4541 const RefItemVector &xrefItems = xrefListItems();
4542 addRefItem(xrefItems,
4543 qualifiedName(),
4544 theTranslator->trCompoundType(compoundType(), lang),
4546 displayName(),
4547 QCString(),
4548 this
4549 );
4550 }
4551 for (const auto &mg : m_memberGroups)
4552 {
4553 mg->addListReferences(this);
4554 }
4555 for (auto &ml : m_memberLists)
4556 {
4557 if (ml->listType().isDetailed())
4558 {
4559 ml->addListReferences(this);
4560 }
4561 }
4562}
4563
4565{
4566 const MemberDef *xmd = nullptr;
4568 if (mni)
4569 {
4570 const int maxInheritanceDepth = 100000;
4571 int mdist=maxInheritanceDepth;
4572 for (auto &mi : *mni)
4573 {
4574 const ClassDef *mcd=mi->memberDef()->getClassDef();
4575 int m=minClassDistance(this,mcd);
4576 //printf("found member in %s linkable=%d m=%d\n",
4577 // qPrint(mcd->name()),mcd->isLinkable(),m);
4578 if (m<mdist)
4579 {
4580 mdist=m;
4581 xmd=mi->memberDef();
4582 }
4583 }
4584 }
4585 //printf("getMemberByName(%s)=%p\n",qPrint(name),xmd);
4586 return xmd;
4587}
4588
4590{
4591 return md->getClassDef() && isBaseClass(md->getClassDef(),TRUE,QCString());
4592}
4593
4595{
4596 for (auto &ml : m_memberLists)
4597 {
4598 if (ml->listType()==lt)
4599 {
4600 return ml.get();
4601 }
4602 }
4603 return nullptr;
4604}
4605
4607{
4608 AUTO_TRACE("{} md={} lt={} isBrief={}",name(),md->name(),lt,isBrief);
4609 bool sortBriefDocs = Config_getBool(SORT_BRIEF_DOCS);
4610 bool sortMemberDocs = Config_getBool(SORT_MEMBER_DOCS);
4611 const auto &ml = m_memberLists.get(lt,MemberListContainer::Class);
4612 ml->setNeedsSorting((isBrief && sortBriefDocs) || (!isBrief && sortMemberDocs));
4613 ml->push_back(md);
4614
4615 // for members in the declaration lists we set the section, needed for member grouping
4616 if (!ml->listType().isDetailed())
4617 {
4619 if (mdm)
4620 {
4621 mdm->setSectionList(this,ml.get());
4622 }
4623 }
4624}
4625
4627{
4628 for (auto &ml : m_memberLists)
4629 {
4630 if (ml->needsSorting()) { ml->sort(); ml->setNeedsSorting(FALSE); }
4631 }
4632 if (Config_getBool(SORT_BRIEF_DOCS))
4633 {
4634 std::stable_sort(m_innerClasses.begin(),
4635 m_innerClasses.end(),
4636 [](const auto &c1,const auto &c2)
4637 {
4638 return Config_getBool(SORT_BY_SCOPE_NAME) ?
4639 qstricmp_sort(c1->name(), c2->name() )<0 :
4640 qstricmp_sort(c1->className(), c2->className())<0 ;
4641 });
4642 }
4643}
4644
4646 MemberListType lt2,bool invert,bool showAlways,ClassDefSet &visitedClasses) const
4647{
4648 //printf("%s: countMemberDeclarations for %s and %s\n",qPrint(name()),lt.to_string(),lt2.to_string());
4649 int count=0;
4650 MemberList * ml = getMemberList(lt);
4651 MemberList * ml2 = getMemberList(lt2);
4652 if (getLanguage()!=SrcLangExt::VHDL) // use specific declarations function
4653 {
4654 if (ml)
4655 {
4656 count+=ml->numDecMembers(inheritedFrom);
4657 //printf("-> ml=%d\n",ml->numDecMembers());
4658 }
4659 if (ml2)
4660 {
4661 count+=ml2->numDecMembers(inheritedFrom);
4662 //printf("-> ml2=%d\n",ml2->numDecMembers());
4663 }
4664 // also include grouped members that have their own section in the class (see bug 722759)
4665 if (inheritedFrom)
4666 {
4667 for (const auto &mg : m_memberGroups)
4668 {
4669 count+=mg->countGroupedInheritedMembers(lt);
4670 if (!lt2.isInvalid()) count+=mg->countGroupedInheritedMembers(lt2);
4671 }
4672 }
4673 bool inlineInheritedMembers = Config_getBool(INLINE_INHERITED_MEMB);
4674 if (!inlineInheritedMembers) // show inherited members as separate lists
4675 {
4676 count+=countInheritedDecMembers(lt,inheritedFrom,invert,showAlways,visitedClasses);
4677 }
4678 }
4679 //printf("-> %d\n",count);
4680 return count;
4681}
4682
4684{
4685 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
4686 {
4687 if (lde->kind()==LayoutDocEntry::MemberDecl)
4688 {
4689 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
4690 if (lmd)
4691 {
4692 MemberList * ml = getMemberList(lmd->type);
4693 if (ml)
4694 {
4696 }
4697 }
4698 }
4699 else if (lde->kind()==LayoutDocEntry::MemberGroups)
4700 {
4701 for (const auto &mg : m_memberGroups)
4702 {
4703 mg->setAnonymousEnumType();
4704 }
4705 }
4706 }
4707}
4708
4710{
4711 for (auto &ml : m_memberLists)
4712 {
4713 ml->countDecMembers();
4714 ml->countDocMembers();
4715 }
4716 for (const auto &mg : m_memberGroups)
4717 {
4718 mg->countDecMembers();
4719 mg->countDocMembers();
4720 }
4721}
4722
4724 const ClassDef *inheritedFrom,bool invert,bool showAlways,
4725 ClassDefSet &visitedClasses) const
4726{
4727 int inhCount = 0;
4728 int count = countMembersIncludingGrouped(lt,inheritedFrom,FALSE);
4729 bool process = count>0;
4730 //printf("%s: countInheritedDecMembers: lt=%s process=%d count=%d invert=%d\n",
4731 // qPrint(name()),lt.to_string(),process,count,invert);
4732 if ((process^invert) || showAlways)
4733 {
4734 for (const auto &ibcd : m_inherits)
4735 {
4736 ClassDefMutable *icd = toClassDefMutable(ibcd.classDef);
4739 if (icd && icd->isLinkable())
4740 {
4741 convertProtectionLevel(lt,ibcd.prot,&lt1,&lt2);
4742 //printf("%s: convert %s->(%s,%s) prot=%d\n",
4743 // qPrint(icd->name()),lt.to_string(),lt1.to_string(),lt2.to_string(),ibcd.prot);
4744 if (visitedClasses.find(icd)==visitedClasses.end())
4745 {
4746 visitedClasses.insert(icd); // guard for multiple virtual inheritance
4747 if (!lt1.isInvalid())
4748 {
4749 inhCount+=icd->countMemberDeclarations(lt1,inheritedFrom,lt2,FALSE,TRUE,visitedClasses);
4750 }
4751 }
4752 }
4753 }
4754 }
4755 //printf("%s: count=%d\n",qPrint(name()),inhCount);
4756 return inhCount;
4757}
4758
4760 QCString &title,QCString &subtitle) const
4761{
4762 SrcLangExt lang = getLanguage();
4763 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
4764 {
4765 if (lde->kind()==LayoutDocEntry::MemberDecl)
4766 {
4767 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
4768 if (lmd && lmd->type==type)
4769 {
4770 title = lmd->title(lang);
4771 subtitle = lmd->subtitle(lang);
4772 return;
4773 }
4774 }
4775 }
4776 title="";
4777 subtitle="";
4778}
4779
4781{
4782 int totalCount=0;
4783 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
4784 {
4785 if (lde->kind()==LayoutDocEntry::MemberDecl)
4786 {
4787 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
4788 if (lmd && lmd->type!=MemberListType::Friends()) // friendship is not inherited
4789 {
4790 ClassDefSet visited;
4791 totalCount+=countInheritedDecMembers(lmd->type,this,TRUE,FALSE,visited);
4792 }
4793 }
4794 }
4795 //printf("countAdditionalInheritedMembers()=%d\n",totalCount);
4796 return totalCount;
4797}
4798
4800{
4801 //printf("**** writeAdditionalInheritedMembers()\n");
4802 for (const auto &lde : LayoutDocManager::instance().docEntries(LayoutDocManager::Class))
4803 {
4804 if (lde->kind()==LayoutDocEntry::MemberDecl)
4805 {
4806 const LayoutDocEntryMemberDecl *lmd = dynamic_cast<const LayoutDocEntryMemberDecl*>(lde.get());
4807 if (lmd && lmd->type!=MemberListType::Friends())
4808 {
4809 ClassDefSet visited;
4811 }
4812 }
4813 }
4814}
4815
4817 const ClassDef *inheritedFrom,bool additional) const
4818{
4819 int count=0;
4820 MemberList *ml = getMemberList(lt);
4821 if (ml)
4822 {
4823 count=ml->countInheritableMembers(inheritedFrom);
4824 }
4825 //printf("%s:countMembersIncludingGrouped: count=%d\n",qPrint(name()),count);
4826 for (const auto &mg : m_memberGroups)
4827 {
4828 bool hasOwnSection = !mg->allMembersInSameSection() ||
4829 !m_subGrouping; // group is in its own section
4830 if ((additional && hasOwnSection) || (!additional && !hasOwnSection))
4831 {
4832 count+=mg->countGroupedInheritedMembers(lt);
4833 }
4834 }
4835 //printf("%s:countMembersIncludingGrouped(lt=%s,%s)=%d\n",
4836 // qPrint(name()),qPrint(lt.to_string()),ml?qPrint(ml->listType().to_string()):"<none>",count);
4837 return count;
4838}
4839
4840
4843 const ClassDef *inheritedFrom,bool invert,bool showAlways) const
4844{
4845 int count = countMembersIncludingGrouped(lt,inheritedFrom,FALSE);
4846 bool process = count>0;
4847 //printf("%s: writeInheritedMemberDec: lt=%s process=%d invert=%d always=%d\n",
4848 // qPrint(name()),qPrint(lt.to_string()),process,invert,showAlways);
4849 if ((process^invert) || showAlways)
4850 {
4851 for (const auto &ibcd : m_inherits)
4852 {
4853 ClassDefMutable *icd=toClassDefMutable(ibcd.classDef);
4854 if (icd && icd->isLinkable())
4855 {
4858 convertProtectionLevel(lt,ibcd.prot,&lt1,&lt3);
4859 if (lt2.isInvalid() && !lt3.isInvalid())
4860 {
4861 lt2=lt3;
4862 }
4863 //printf("%s:convert %s->(%s,%s) prot=%d\n",qPrint(icd->name()),qPrint(lt.to_string()),
4864 // qPrint(lt1.to_string()),qPrint(lt2.to_string()),ibcd.prot);
4865 if (visitedClasses.find(icd)==visitedClasses.end())
4866 {
4867 visitedClasses.insert(icd); // guard for multiple virtual inheritance
4868 if (!lt1.isInvalid())
4869 {
4870 //printf("--> writeMemberDeclarations for type %s\n",qPrint(lt1.to_string()));
4871 icd->writeMemberDeclarations(ol,visitedClasses,lt1,
4872 title,QCString(),FALSE,inheritedFrom,lt2,FALSE,TRUE);
4873 }
4874 }
4875 else
4876 {
4877 //printf("%s: class already visited!\n",qPrint(icd->name()));
4878 }
4879 }
4880 }
4881 }
4882}
4883
4885 MemberListType lt,const QCString &title,
4886 const QCString &subTitle,bool showInline,const ClassDef *inheritedFrom,MemberListType lt2,
4887 bool invert,bool showAlways) const
4888{
4889 //printf("%s: ClassDefImpl::writeMemberDeclarations lt=%s lt2=%s\n",qPrint(name()),qPrint(lt.to_string()),qPrint(lt2.to_string()));
4890 MemberList * ml = getMemberList(lt);
4891 MemberList * ml2 = getMemberList(lt2);
4892 if (getLanguage()==SrcLangExt::VHDL) // use specific declarations function
4893 {
4894 static const ClassDef *cdef;
4895 if (cdef!=this)
4896 { // only one inline link
4898 cdef=this;
4899 }
4900 if (ml)
4901 {
4902 VhdlDocGen::writeVhdlDeclarations(ml,ol,nullptr,this,nullptr,nullptr,nullptr);
4903 }
4904 }
4905 else
4906 {
4907 //printf("%s::writeMemberDeclarations(%s) ml=%p ml2=%p\n",qPrint(name()),qPrint(title),(void*)ml,(void*)ml2);
4908 QCString tt = title, st = subTitle;
4909 if (ml)
4910 {
4911 //printf(" writeDeclarations ml type=%s count=%d\n",qPrint(lt.to_string()),ml->numDecMembers(inheritedFrom));
4912 ml->writeDeclarations(ol,this,nullptr,nullptr,nullptr,nullptr,tt,st,FALSE,showInline,inheritedFrom,lt,true);
4913 tt.clear();
4914 st.clear();
4915 }
4916 if (ml2)
4917 {
4918 //printf(" writeDeclarations ml2 type=%s count=%d\n",qPrint(lt2.to_string()),ml2->numDecMembers(inheritedFrom));
4919 ml2->writeDeclarations(ol,this,nullptr,nullptr,nullptr,nullptr,tt,st,FALSE,showInline,inheritedFrom,lt,ml==nullptr);
4920 }
4921 bool inlineInheritedMembers = Config_getBool(INLINE_INHERITED_MEMB);
4922 if (!inlineInheritedMembers) // show inherited members as separate lists
4923 {
4924 writeInheritedMemberDeclarations(ol,visitedClasses,lt,lt2,title,
4925 inheritedFrom ? inheritedFrom : this,
4926 invert,showAlways);
4927 }
4928 }
4929}
4930
4932 const ClassDef *inheritedFrom,const QCString &inheritId) const
4933{
4934 //printf("** %s::addGroupedInheritedMembers() inheritId=%s\n",qPrint(name()),qPrint(inheritId));
4935 for (const auto &mg : m_memberGroups)
4936 {
4937 if (!mg->allMembersInSameSection() || !m_subGrouping) // group is in its own section
4938 {
4939 mg->addGroupedInheritedMembers(ol,this,lt,inheritedFrom,inheritId);
4940 }
4941 }
4942}
4943
4945{
4946 //printf("%s: ClassDefImpl::writeMemberDocumentation()\n",qPrint(name()));
4947 MemberList * ml = getMemberList(lt);
4948 if (ml) ml->writeDocumentation(ol,displayName(),this,title,ml->listType().toLabel(),FALSE,showInline);
4949}
4950
4952{
4953 //printf("%s: ClassDefImpl::writeSimpleMemberDocumentation()\n",qPrint(name()));
4954 MemberList * ml = getMemberList(lt);
4955 if (ml) ml->writeSimpleDocumentation(ol,this);
4956}
4957
4959 MemberListType lt,bool inGroup,
4960 int indentLevel,const ClassDef *inheritedFrom,const QCString &inheritId) const
4961{
4962 //printf("%s: ClassDefImpl::writePlainMemberDeclaration()\n",qPrint(name()));
4963 MemberList * ml = getMemberList(lt);
4964 if (ml)
4965 {
4966 ml->writePlainDeclarations(ol,inGroup,this,nullptr,nullptr,nullptr,nullptr,indentLevel,inheritedFrom,inheritId);
4967 }
4968}
4969
4971{
4972 return m_isLocal;
4973}
4974
4979
4984
4986{
4987 return m_inherits;
4988}
4989
4991{
4992 m_inherits = bcd;
4993}
4994
4996{
4997 return m_inheritedBy;
4998}
4999
5001{
5002 m_inheritedBy = bcd;
5003}
5004
5009
5011{
5012 std::stable_sort(m_allMemberNameInfoLinkedMap.begin(),
5014 [](const auto &m1,const auto &m2)
5015 {
5016 return qstricmp_sort(m1->memberName(),m2->memberName())<0;
5017 });
5018}
5019
5021{
5022 return m_prot;
5023}
5024
5026{
5027 return m_tempArgs;
5028}
5029
5031{
5032 return m_fileDef;
5033}
5034
5036{
5037 return m_moduleDef;
5038}
5039
5044
5046{
5047 return m_templateMaster;
5048}
5049
5054
5059
5061{
5062 return !m_tempArgs.empty();
5063}
5064
5066{
5067 return m_incInfo.get();
5068}
5069
5074
5079
5084
5086{
5087 return m_isTemplArg;
5088}
5089
5091{
5092 return m_isAbstract || m_spec.isAbstract();
5093}
5094
5096{
5097 return m_spec.isFinal();
5098}
5099
5101{
5102 return m_spec.isSealed();
5103}
5104
5106{
5107 return m_spec.isPublished();
5108}
5109
5111{
5112 return m_spec.isForwardDecl();
5113}
5114
5116{
5117 return m_spec.isInterface();
5118}
5119
5121{
5122 return getLanguage()==SrcLangExt::ObjC;
5123}
5124
5126{
5127 return getLanguage()==SrcLangExt::Fortran;
5128}
5129
5131{
5132 return getLanguage()==SrcLangExt::CSharp;
5133}
5134
5136{
5137 return m_categoryOf;
5138}
5139
5141{
5142 return m_memberLists;
5143}
5144
5146{
5147 return m_memberGroups;
5148}
5149
5151{
5152 m_fileDef = fd;
5153}
5154
5156{
5157 m_moduleDef = mod;
5158}
5159
5161{
5162 m_subGrouping = enabled;
5163}
5164
5166{
5167 m_prot=p;
5168 if (getLanguage()==SrcLangExt::VHDL && VhdlDocGen::convert(p)==VhdlDocGen::ARCHITECTURECLASS)
5169 {
5170 m_className = name();
5171 }
5172}
5173
5175{
5176 m_isStatic=b;
5177}
5178
5183
5185{
5186 assert(tm!=this);
5188}
5189
5191{
5192 m_isTemplArg = b;
5193}
5194
5196{
5197 m_categoryOf = cd;
5198}
5199
5201{
5202 m_usedOnly = b;
5203}
5204
5206{
5207 return m_usedOnly;
5208}
5209
5211{
5212 return m_isSimple;
5213}
5214
5216{
5217 return m_arrowOperator;
5218}
5219
5221{
5222 md->setMemberType(t);
5223 for (auto &ml : m_memberLists)
5224 {
5225 ml->remove(md);
5226 }
5227 insertMember(md);
5228}
5229
5231{
5232 QCString anc;
5234 {
5236 {
5237 // point to the template of which this class is an instance
5238 anc = m_templateMaster->getOutputFileBase();
5239 }
5240 else
5241 {
5242 anc = m_fileName;
5243 }
5244 }
5245 return anc;
5246}
5247
5249{
5250 bool inlineGroupedClasses = Config_getBool(INLINE_GROUPED_CLASSES);
5251 bool inlineSimpleClasses = Config_getBool(INLINE_SIMPLE_STRUCTS);
5252
5253 Definition *container = getOuterScope();
5254
5255 bool containerLinkable =
5256 container &&
5257 (
5258 (container==Doxygen::globalScope && getFileDef() && getFileDef()->isLinkableInProject()) || // global class in documented file
5259 container->isLinkableInProject() // class in documented scope
5260 );
5261
5262 // inline because of INLINE_GROUPED_CLASSES=YES ?
5263 bool b1 = (inlineGroupedClasses && !partOfGroups().empty()); // a grouped class
5264 // inline because of INLINE_SIMPLE_STRUCTS=YES ?
5265 bool b2 = (inlineSimpleClasses && m_isSimple && // a simple class
5266 (containerLinkable || // in a documented container
5267 !partOfGroups().empty() // or part of a group
5268 )
5269 );
5270 //printf("%s::isEmbeddedInOuterScope(): inlineGroupedClasses=%d "
5271 // "inlineSimpleClasses=%d partOfGroups()=%p m_isSimple=%d "
5272 // "getOuterScope()=%s b1=%d b2=%d\n",
5273 // qPrint(name()),inlineGroupedClasses,inlineSimpleClasses,
5274 // partOfGroups().pointer(),m_isSimple,getOuterScope()?qPrint(getOuterScope()->name()):"<none>",b1,b2);
5275 return b1 || b2; // either reason will do
5276}
5277
5279{
5280 return m_tagLessRef;
5281}
5282
5284{
5285 m_tagLessRef = cd;
5286}
5287
5289{
5290 for (auto &ml : m_memberLists)
5291 {
5292 ml->remove(md);
5293 }
5294}
5295
5297{
5298 return m_isJavaEnum;
5299}
5300
5302{
5303 m_spec = spec;
5304}
5305
5307{
5308 for (const auto &sx : qualifiers)
5309 {
5310 bool alreadyAdded = std::find(m_qualifiers.begin(), m_qualifiers.end(), sx) != m_qualifiers.end();
5311 if (!alreadyAdded)
5312 {
5313 m_qualifiers.push_back(sx);
5314 }
5315 }
5316}
5317
5322
5324{
5325 AUTO_TRACE("name={}",md->name());
5326 const auto &mni = m_allMemberNameInfoLinkedMap.find(md->name());
5327 if (mni)
5328 {
5329 for (const auto &mi : *mni)
5330 {
5331 const MemberDef *classMd = mi->memberDef();
5332 const ArgumentList &classAl = classMd->argumentList();
5333 const ArgumentList &al = md->argumentList();
5334 bool found = matchArguments2(
5335 classMd->getOuterScope(),classMd->getFileDef(),&classAl,
5336 md->getOuterScope(),md->getFileDef(),&al,
5337 true,getLanguage()
5338 );
5339 if (found)
5340 {
5341 AUTO_TRACE_EXIT("true");
5342 return true;
5343 }
5344 }
5345 }
5346 AUTO_TRACE_EXIT("false");
5347 return false;
5348}
5349
5351{
5352 QCString n = name();
5353 int si = n.find('(');
5354 int ei = n.find(')');
5355 bool b = ei>si && n.mid(si+1,ei-si-1).stripWhiteSpace().isEmpty();
5356 return b;
5357}
5358
5360{
5361 return m_files;
5362}
5363
5365{
5366 return m_typeConstraints;
5367}
5368
5370{
5371 return m_examples;
5372}
5373
5375{
5376 return m_subGrouping;
5377}
5378
5380{
5381 return m_spec.isLocal();
5382}
5383
5385{
5386 m_metaData = md;
5387}
5388
5393
5398
5400{
5402}
5403
5405{
5407}
5408
5410{
5411 switch (compoundType())
5412 {
5413 case Class: return CodeSymbolType::Class; break;
5414 case Struct: return CodeSymbolType::Struct; break;
5415 case Union: return CodeSymbolType::Union; break;
5416 case Interface: return CodeSymbolType::Interface; break;
5417 case Protocol: return CodeSymbolType::Protocol; break;
5418 case Category: return CodeSymbolType::Category; break;
5419 case Exception: return CodeSymbolType::Exception; break;
5420 case Service: return CodeSymbolType::Service; break;
5421 case Singleton: return CodeSymbolType::Singleton; break;
5422 }
5423 return CodeSymbolType::Class;
5424}
5425
5430
5435
5436
5437// --- Cast functions
5438//
5440{
5441 if (d && (typeid(*d)==typeid(ClassDefImpl) || typeid(*d)==typeid(ClassDefAliasImpl)))
5442 {
5443 return static_cast<ClassDef*>(d);
5444 }
5445 else
5446 {
5447 return nullptr;
5448 }
5449}
5450
5452{
5453 Definition *d = toDefinition(md);
5454 if (d && typeid(*d)==typeid(ClassDefImpl))
5455 {
5456 return static_cast<ClassDef*>(d);
5457 }
5458 else
5459 {
5460 return nullptr;
5461 }
5462}
5463
5465{
5466 if (d && (typeid(*d)==typeid(ClassDefImpl) || typeid(*d)==typeid(ClassDefAliasImpl)))
5467 {
5468 return static_cast<const ClassDef*>(d);
5469 }
5470 else
5471 {
5472 return nullptr;
5473 }
5474}
5475
5477{
5478 if (d && typeid(*d)==typeid(ClassDefImpl))
5479 {
5480 return static_cast<ClassDefMutable*>(d);
5481 }
5482 else
5483 {
5484 return nullptr;
5485 }
5486}
5487
5488// --- Helpers
5489
5490/*! Get a class definition given its name.
5491 * Returns nullptr if the class is not found.
5492 */
5494{
5495 if (n.isEmpty()) return nullptr;
5496 return Doxygen::classLinkedMap->find(n);
5497}
5498
5500{
5501 for (const auto &bcd : bcl)
5502 {
5503 const ClassDef *cd=bcd.classDef;
5504 if (cd->isVisibleInHierarchy()) return true;
5505 if (classHasVisibleRoot(cd->baseClasses())) return true;
5506 }
5507 return false;
5508}
5509
5511{
5512 BaseClassList bcl;
5513
5514 if (cd->getLanguage()==SrcLangExt::VHDL) // reverse baseClass/subClass relation
5515 {
5516 if (cd->baseClasses().empty()) return FALSE;
5517 bcl=cd->baseClasses();
5518 }
5519 else
5520 {
5521 if (cd->subClasses().empty()) return FALSE;
5522 bcl=cd->subClasses();
5523 }
5524
5525 for (const auto &bcd : bcl)
5526 {
5527 if (bcd.classDef->isVisibleInHierarchy())
5528 {
5529 return TRUE;
5530 }
5531 }
5532 return FALSE;
5533}
5534
5536{
5537 bool allExternals = Config_getBool(ALLEXTERNALS);
5538 return (allExternals && cd->isLinkable()) || cd->isLinkableInProject();
5539}
5540
5541//----------------------------------------------------------------------
5542// recursive function that returns the number of branches in the
5543// inheritance tree that the base class 'bcd' is below the class 'cd'
5544
5545int minClassDistance(const ClassDef *cd,const ClassDef *bcd,int level)
5546{
5547 const int maxInheritanceDepth = 100000;
5548 if (bcd->categoryOf()) // use class that is being extended in case of
5549 // an Objective-C category
5550 {
5551 bcd=bcd->categoryOf();
5552 }
5553 if (cd==bcd) return level;
5554 if (level==256)
5555 {
5556 warn_uncond("class {} seem to have a recursive inheritance relation!\n",cd->name());
5557 return -1;
5558 }
5559 int m=maxInheritanceDepth;
5560 for (const auto &bcdi : cd->baseClasses())
5561 {
5562 int mc=minClassDistance(bcdi.classDef,bcd,level+1);
5563 if (mc<m) m=mc;
5564 if (m<0) break;
5565 }
5566 return m;
5567}
5568
5570{
5571 if (bcd->categoryOf()) // use class that is being extended in case of
5572 // an Objective-C category
5573 {
5574 bcd=bcd->categoryOf();
5575 }
5576 if (cd==bcd)
5577 {
5578 goto exit;
5579 }
5580 if (level==256)
5581 {
5582 err("Internal inconsistency: found class {} seem to have a recursive "
5583 "inheritance relation! Please send a bug report to doxygen@gmail.com\n",cd->name());
5584 }
5585 else if (prot!=Protection::Private)
5586 {
5587 for (const auto &bcdi : cd->baseClasses())
5588 {
5589 Protection baseProt = classInheritedProtectionLevel(bcdi.classDef,bcd,bcdi.prot,level+1);
5590 if (baseProt==Protection::Private) prot=Protection::Private;
5591 else if (baseProt==Protection::Protected) prot=Protection::Protected;
5592 }
5593 }
5594exit:
5595 //printf("classInheritedProtectionLevel(%s,%s)=%d\n",qPrint(cd->name()),qPrint(bcd->name()),prot);
5596 return prot;
5597}
5598
5599
constexpr auto prefix
Definition anchor.cpp:44
std::vector< ArgumentList > ArgumentLists
Definition arguments.h:145
This class represents an function or template argument list.
Definition arguments.h:65
bool empty() const
Definition arguments.h:99
Argument & at(size_t i)
Definition arguments.h:107
bool isSimple() const override
Definition classdef.cpp:706
bool isFortran() const override
Returns TRUE if this class is implemented in Fortran.
Definition classdef.cpp:672
QCString requiresClause() const override
Definition classdef.cpp:734
void writeTagFile(TextStream &ol) const override
Definition classdef.cpp:772
int countMemberDeclarations(MemberListType lt, const ClassDef *inheritedFrom, MemberListType lt2, bool invert, bool showAlways, ClassDefSet &visitedClasses) const override
Definition classdef.cpp:743
bool isSubClass(ClassDef *bcd, int level=0) const override
Returns TRUE iff bcd is a direct or indirect sub class of this class.
Definition classdef.cpp:641
const UsesClassList & usedByImplementationClasses() const override
Definition classdef.cpp:655
bool hasDetailedDescription() const override
returns TRUE if this class has a non-empty detailed description
Definition classdef.cpp:603
void writePageNavigation(OutputList &ol) const override
Definition classdef.cpp:768
ModuleDef * getModuleDef() const override
Returns the C++20 module in which this compound's definition can be found.
Definition classdef.cpp:635
void writeDocumentation(OutputList &ol) const override
Definition classdef.cpp:753
const UsesClassList & usedImplementationClasses() const override
Definition classdef.cpp:653
StringVector getQualifiers() const override
Definition classdef.cpp:736
void writeSummaryLinks(OutputList &ol) const override
Definition classdef.cpp:766
bool isVisibleInHierarchy() const override
the class is visible in a class diagram, or class hierarchy
Definition classdef.cpp:627
QCString qualifiedNameWithTemplateParameters(const ArgumentLists *actualParams=nullptr, uint32_t *actualParamIndex=nullptr) const override
Definition classdef.cpp:665
bool isPublished() const override
Returns TRUE if this class is marked as published.
Definition classdef.cpp:680
const MemberNameInfoLinkedMap & memberNameInfoLinkedMap() const override
Returns a dictionary of all members.
Definition classdef.cpp:619
QCString anchor() const override
Definition classdef.cpp:702
QCString title() const override
Definition classdef.cpp:714
bool isImplicitTemplateInstance() const override
Definition classdef.cpp:750
const FileList & usedFiles() const override
Definition classdef.cpp:718
CodeSymbolType codeSymbolType() const override
Definition classdef.cpp:585
bool isFinal() const override
Returns TRUE if this class is marked as final.
Definition classdef.cpp:676
const ExampleList & getExamples() const override
Definition classdef.cpp:722
void moveTo(Definition *) override
Definition classdef.cpp:583
bool isReference() const override
Definition classdef.cpp:595
bool isTemplateArgument() const override
Definition classdef.cpp:659
void updateSubClasses(const BaseClassList &) override
Update the list of sub classes to the one passed.
Definition classdef.cpp:785
bool isForwardDeclared() const override
Returns TRUE if this class represents a forward declaration of a template class.
Definition classdef.cpp:684
const ArgumentList & typeConstraints() const override
Definition classdef.cpp:720
const IncludeInfo * includeInfo() const override
Definition classdef.cpp:651
bool isAccessibleMember(const MemberDef *md) const override
returns TRUE iff md is a member of this class or of the the public/protected members of a base class
Definition classdef.cpp:643
QCString getSourceFileBase() const override
Definition classdef.cpp:591
void writeMemberPages(OutputList &ol) const override
Definition classdef.cpp:757
ClassDefAliasImpl(const Definition *newScope, const ClassDef *cd)
Definition classdef.cpp:572
void writeDeclaration(OutputList &ol, const MemberDef *md, bool inGroup, int indentLevel, const ClassDef *inheritedFrom, const QCString &inheritId) const override
Definition classdef.cpp:761
void writeQuickMemberLinks(OutputList &ol, const MemberDef *md) const override
Definition classdef.cpp:764
void updateBaseClasses(const BaseClassList &) override
Update the list of base classes to the one passed.
Definition classdef.cpp:784
bool containsOverload(const MemberDef *md) const override
Definition classdef.cpp:738
bool subGrouping() const override
Definition classdef.cpp:728
const ArgumentList & templateArguments() const override
Returns the template arguments of this class.
Definition classdef.cpp:631
Protection protection() const override
Return the protection level (Public,Protected,Private) in which this compound was found.
Definition classdef.cpp:621
bool isCSharp() const override
Returns TRUE if this class is implemented in C#.
Definition classdef.cpp:674
const MemberGroupList & getMemberGroups() const override
Returns the member groups defined for this class.
Definition classdef.cpp:696
bool isEmbeddedInOuterScope() const override
Definition classdef.cpp:704
QCString getReference() const override
Definition classdef.cpp:593
int isBaseClass(const ClassDef *bcd, bool followInstances, const QCString &templSpec) const override
Returns TRUE iff bcd is a direct or indirect base class of this class.
Definition classdef.cpp:639
int countMembersIncludingGrouped(MemberListType lt, const ClassDef *inheritedFrom, bool additional) const override
Definition classdef.cpp:741
void addGroupedInheritedMembers(OutputList &ol, MemberListType lt, const ClassDef *inheritedFrom, const QCString &inheritId) const override
Definition classdef.cpp:780
bool isSealed() const override
Returns TRUE if this class is marked as sealed.
Definition classdef.cpp:678
bool hasDocumentation() const override
Definition classdef.cpp:601
FileDef * getFileDef() const override
Returns the namespace this compound is in, or 0 if it has a global scope.
Definition classdef.cpp:633
ArgumentLists getTemplateParameterLists() const override
Returns the template parameter lists that form the template declaration of this class.
Definition classdef.cpp:663
QCString getMemberListFileName() const override
Definition classdef.cpp:726
bool hasNonReferenceSuperClass() const override
Definition classdef.cpp:732
void writeInlineDocumentation(OutputList &ol) const override
Definition classdef.cpp:770
const BaseClassList & subClasses() const override
Returns the list of sub classes that directly derive from this class.
Definition classdef.cpp:617
bool isJavaEnum() const override
Definition classdef.cpp:712
QCString inheritanceGraphFileName() const override
returns the file name to use for the inheritance graph
Definition classdef.cpp:607
~ClassDefAliasImpl() override
Definition classdef.cpp:574
const TemplateInstanceList & getTemplateInstances() const override
Returns a sorted dictionary with all template instances found for this template class.
Definition classdef.cpp:645
QCString compoundTypeString() const override
Returns the type of compound as a string.
Definition classdef.cpp:613
bool isLinkableInProject() const override
Definition classdef.cpp:623
QCString displayName(bool includeScope=TRUE) const override
Definition classdef.cpp:609
QCString className() const override
Returns the name of the class including outer classes, but not including namespaces.
Definition classdef.cpp:690
bool isLocal() const override
Returns TRUE if this is a local class definition, see EXTRACT_LOCAL_CLASSES.
Definition classdef.cpp:597
QCString getInstanceOutputFileBase() const override
Definition classdef.cpp:589
void writeDocumentationForInnerClasses(OutputList &ol) const override
Definition classdef.cpp:755
const MemberLists & getMemberLists() const override
Returns the list containing the list of members sorted per type.
Definition classdef.cpp:694
MemberList * getMemberList(MemberListType lt) const override
Returns the members in the list identified by lt.
Definition classdef.cpp:692
ClassDef * categoryOf() const override
Returns the class of which this is a category (Objective-C only).
Definition classdef.cpp:688
const ClassDef * getCdAlias() const
Definition classdef.cpp:579
QCString collaborationGraphFileName() const override
returns the file name to use for the collaboration graph
Definition classdef.cpp:605
void writeMemberDeclarations(OutputList &ol, ClassDefSet &visitedClasses, MemberListType lt, const QCString &title, const QCString &subTitle=QCString(), bool showInline=FALSE, const ClassDef *inheritedFrom=nullptr, MemberListType lt2=MemberListType::Invalid(), bool invert=FALSE, bool showAlways=FALSE) const override
Definition classdef.cpp:774
QCString getOutputFileBase() const override
Definition classdef.cpp:587
CompoundType compoundType() const override
Returns the type of compound this is, i.e.
Definition classdef.cpp:611
const TemplateNameMap & getTemplateBaseClassNames() const override
Definition classdef.cpp:698
void writeDeclarationLink(OutputList &ol, bool &found, const QCString &header, bool localNames) const override
Definition classdef.cpp:747
const Definition * findInnerCompound(const QCString &name) const override
Definition classdef.cpp:661
DefType definitionType() const override
Definition classdef.cpp:577
QCString generatedFromFiles() const override
Definition classdef.cpp:716
bool isLinkable() const override
Definition classdef.cpp:625
const BaseClassList & baseClasses() const override
Returns the list of base classes from which this class directly inherits.
Definition classdef.cpp:615
const ClassDef * tagLessReference() const override
Definition classdef.cpp:708
bool isExtension() const override
Returns TRUE if this class represents an Objective-C 2.0 extension (nameless category).
Definition classdef.cpp:682
ClassLinkedRefMap getClasses() const override
returns the classes nested into this class
Definition classdef.cpp:599
const ConstraintClassList & templateTypeConstraints() const override
Definition classdef.cpp:657
bool isInterface() const override
Returns TRUE if this class represents an interface.
Definition classdef.cpp:686
std::unique_ptr< ClassDef > deepCopy(const QCString &name) const override
Definition classdef.cpp:580
bool isAbstract() const override
Returns TRUE if there is at least one pure virtual member in this class.
Definition classdef.cpp:668
bool hasExamples() const override
Definition classdef.cpp:724
bool visibleInParentsDeclList() const override
show this class in the declaration section of its parent?
Definition classdef.cpp:629
const MemberDef * getMemberByName(const QCString &s) const override
Returns the member with the given name.
Definition classdef.cpp:637
const ClassDef * templateMaster() const override
Returns the template master of which this class is an instance.
Definition classdef.cpp:647
bool isTemplate() const override
Returns TRUE if this class is a template.
Definition classdef.cpp:649
bool isSliceLocal() const override
Definition classdef.cpp:730
bool isUsedOnly() const override
Definition classdef.cpp:700
const MemberDef * isSmartPointer() const override
Definition classdef.cpp:710
bool isObjectiveC() const override
Returns TRUE if this class is implemented in Objective-C.
Definition classdef.cpp:670
void writeMemberList(OutputList &ol) const override
Definition classdef.cpp:759
A abstract class representing of a compound symbol.
Definition classdef.h:104
virtual int countMemberDeclarations(MemberListType lt, const ClassDef *inheritedFrom, MemberListType lt2, bool invert, bool showAlways, ClassDefSet &visitedClasses) const =0
virtual bool isSliceLocal() const =0
virtual ModuleDef * getModuleDef() const =0
Returns the C++20 module in which this compound's definition can be found.
virtual bool isAbstract() const =0
Returns TRUE if there is at least one pure virtual member in this class.
virtual bool isFinal() const =0
Returns TRUE if this class is marked as final.
virtual bool visibleInParentsDeclList() const =0
show this class in the declaration section of its parent?
virtual bool subGrouping() const =0
virtual void writeSummaryLinks(OutputList &ol) const =0
virtual bool hasDetailedDescription() const =0
returns TRUE if this class has a non-empty detailed description
virtual const ArgumentList & templateArguments() const =0
Returns the template arguments of this class.
virtual void writeMemberPages(OutputList &ol) const =0
virtual QCString compoundTypeString() const =0
Returns the type of compound as a string.
virtual bool isFortran() const =0
Returns TRUE if this class is implemented in Fortran.
virtual void writeDocumentation(OutputList &ol) const =0
virtual const MemberLists & getMemberLists() const =0
Returns the list containing the list of members sorted per type.
virtual QCString className() const =0
Returns the name of the class including outer classes, but not including namespaces.
virtual void writeMemberList(OutputList &ol) const =0
virtual bool isVisibleInHierarchy() const =0
the class is visible in a class diagram, or class hierarchy
virtual bool isTemplate() const =0
Returns TRUE if this class is a template.
virtual const BaseClassList & baseClasses() const =0
Returns the list of base classes from which this class directly inherits.
virtual bool isSealed() const =0
Returns TRUE if this class is marked as sealed.
virtual const MemberDef * getMemberByName(const QCString &) const =0
Returns the member with the given name.
virtual const TemplateInstanceList & getTemplateInstances() const =0
Returns a sorted dictionary with all template instances found for this template class.
virtual int isBaseClass(const ClassDef *bcd, bool followInstances, const QCString &templSpec=QCString()) const =0
Returns TRUE iff bcd is a direct or indirect base class of this class.
virtual ArgumentLists getTemplateParameterLists() const =0
Returns the template parameter lists that form the template declaration of this class.
virtual const UsesClassList & usedImplementationClasses() const =0
virtual bool isObjectiveC() const =0
Returns TRUE if this class is implemented in Objective-C.
virtual bool hasExamples() const =0
virtual QCString inheritanceGraphFileName() const =0
returns the file name to use for the inheritance graph
virtual StringVector getQualifiers() const =0
virtual bool isLocal() const =0
Returns TRUE if this is a local class definition, see EXTRACT_LOCAL_CLASSES.
virtual void writeQuickMemberLinks(OutputList &ol, const MemberDef *md) const =0
virtual bool isSimple() const =0
virtual Protection protection() const =0
Return the protection level (Public,Protected,Private) in which this compound was found.
virtual const ClassDef * tagLessReference() const =0
virtual MemberList * getMemberList(MemberListType lt) const =0
Returns the members in the list identified by lt.
virtual void writePageNavigation(OutputList &ol) const =0
virtual ClassDef * categoryOf() const =0
Returns the class of which this is a category (Objective-C only).
virtual QCString getInstanceOutputFileBase() const =0
virtual const MemberDef * isSmartPointer() const =0
virtual bool isExtension() const =0
Returns TRUE if this class represents an Objective-C 2.0 extension (nameless category).
virtual bool hasNonReferenceSuperClass() const =0
virtual bool isCSharp() const =0
Returns TRUE if this class is implemented in C#.
virtual bool isForwardDeclared() const =0
Returns TRUE if this class represents a forward declaration of a template class.
virtual QCString generatedFromFiles() const =0
virtual const ExampleList & getExamples() const =0
virtual bool isJavaEnum() const =0
virtual bool isSubClass(ClassDef *bcd, int level=0) const =0
Returns TRUE iff bcd is a direct or indirect sub class of this class.
virtual bool isTemplateArgument() const =0
virtual int countMembersIncludingGrouped(MemberListType lt, const ClassDef *inheritedFrom, bool additional) const =0
virtual const ArgumentList & typeConstraints() const =0
virtual bool isAccessibleMember(const MemberDef *md) const =0
returns TRUE iff md is a member of this class or of the the public/protected members of a base class
virtual QCString collaborationGraphFileName() const =0
returns the file name to use for the collaboration graph
virtual const TemplateNameMap & getTemplateBaseClassNames() const =0
virtual bool isPublished() const =0
Returns TRUE if this class is marked as published.
virtual const FileList & usedFiles() const =0
virtual void writeMemberDeclarations(OutputList &ol, ClassDefSet &visitedClasses, MemberListType lt, const QCString &title, const QCString &subTitle=QCString(), bool showInline=FALSE, const ClassDef *inheritedFrom=nullptr, MemberListType lt2=MemberListType::Invalid(), bool invert=FALSE, bool showAlways=FALSE) const =0
virtual QCString getMemberListFileName() const =0
virtual bool isEmbeddedInOuterScope() const =0
virtual void addGroupedInheritedMembers(OutputList &ol, MemberListType lt, const ClassDef *inheritedFrom, const QCString &inheritId) const =0
virtual const MemberNameInfoLinkedMap & memberNameInfoLinkedMap() const =0
Returns a dictionary of all members.
virtual void writeDeclarationLink(OutputList &ol, bool &found, const QCString &header, bool localNames) const =0
virtual const ConstraintClassList & templateTypeConstraints() const =0
virtual void writeDeclaration(OutputList &ol, const MemberDef *md, bool inGroup, int indentLevel, const ClassDef *inheritedFrom, const QCString &inheritId) const =0
virtual bool isImplicitTemplateInstance() const =0
virtual QCString qualifiedNameWithTemplateParameters(const ArgumentLists *actualParams=nullptr, uint32_t *actualParamIndex=nullptr) const =0
virtual const MemberGroupList & getMemberGroups() const =0
Returns the member groups defined for this class.
virtual const UsesClassList & usedByImplementationClasses() const =0
virtual const ClassDef * templateMaster() const =0
Returns the template master of which this class is an instance.
CompoundType
The various compound types.
Definition classdef.h:109
@ Singleton
Definition classdef.h:117
@ Interface
Definition classdef.h:112
@ Exception
Definition classdef.h:115
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e.
virtual bool containsOverload(const MemberDef *md) const =0
virtual ClassLinkedRefMap getClasses() const =0
returns the classes nested into this class
virtual bool isInterface() const =0
Returns TRUE if this class represents an interface.
virtual FileDef * getFileDef() const =0
Returns the namespace this compound is in, or 0 if it has a global scope.
virtual const IncludeInfo * includeInfo() const =0
virtual QCString requiresClause() const =0
virtual void writeInlineDocumentation(OutputList &ol) const =0
virtual void writeTagFile(TextStream &) const =0
virtual QCString title() const =0
virtual void writeDocumentationForInnerClasses(OutputList &ol) const =0
virtual const BaseClassList & subClasses() const =0
Returns the list of sub classes that directly derive from this class.
virtual bool isUsedOnly() const =0
Implementation of the ClassDef interface.
Definition classdef.cpp:185
bool isSubClass(ClassDef *bcd, int level=0) const override
Returns TRUE iff bcd is a direct or indirect sub class of this class.
bool addExample(const QCString &anchor, const QCString &name, const QCString &file) override
QCString getReference() const override
QCString getInstanceOutputFileBase() const override
TemplateInstanceList m_templateInstances
Definition classdef.cpp:487
void writeIncludeFilesForSlice(OutputList &ol) const
void overrideInheritanceGraph(CLASS_GRAPH_t e) override
ClassLinkedRefMap getClasses() const override
returns the classes nested into this class
QCString m_collabFileName
Definition classdef.cpp:419
ArgumentList m_typeConstraints
Definition classdef.cpp:456
void writePageNavigation(OutputList &ol) const override
void addMembersToMemberGroup() override
bool subGrouping() const override
void setMetaData(const QCString &md) override
void distributeMemberGroupDocumentation() override
void addMemberToList(MemberListType lt, MemberDef *md, bool isBrief)
bool isObjectiveC() const override
Returns TRUE if this class is implemented in Objective-C.
StringSet m_vhdlSummaryTitles
List of titles to use for the summary.
Definition classdef.cpp:531
QCString compoundTypeString() const override
Returns the type of compound as a string.
ExampleList m_examples
Definition classdef.cpp:462
void setImplicitTemplateInstance(bool b) override
void insertUsedFile(const FileDef *) override
QCString qualifiedNameWithTemplateParameters(const ArgumentLists *actualParams=nullptr, uint32_t *actualParamIndex=nullptr) const override
void writeTemplateSpec(OutputList &ol, const Definition *d, const QCString &type, SrcLangExt lang) const
void addUsedByClass(ClassDef *cd, const QCString &accessName, Protection prot) override
QCString m_fileName
Definition classdef.cpp:413
const MemberDef * m_arrowOperator
Does this class overloaded the -> operator?
Definition classdef.cpp:537
void addClassAttributes(OutputList &ol) const
void updateSubClasses(const BaseClassList &bcd) override
Update the list of sub classes to the one passed.
void addMemberToTemplateInstance(const MemberDef *md, const ArgumentList &templateArguments, const QCString &templSpec) override
MemberGroupList m_memberGroups
Definition classdef.cpp:505
TypeSpecifier m_spec
Definition classdef.cpp:544
ClassDef * m_categoryOf
Definition classdef.cpp:500
FileDef * getFileDef() const override
Returns the namespace this compound is in, or 0 if it has a global scope.
bool isTemplateArgument() const override
void writeInheritanceGraph(OutputList &ol) const
QCString className() const override
Returns the name of the class including outer classes, but not including namespaces.
const ClassDef * m_tagLessRef
Definition classdef.cpp:539
void setAnonymousEnumType() override
void setTagLessReference(const ClassDef *cd) override
Protection m_prot
Definition classdef.cpp:471
bool isLinkableInProject() const override
BaseClassList m_inheritedBy
Definition classdef.cpp:436
FileList m_files
Definition classdef.cpp:459
const TemplateInstanceList & getTemplateInstances() const override
Returns a sorted dictionary with all template instances found for this template class.
MemberLists m_memberLists
Definition classdef.cpp:502
const UsesClassList & usedByImplementationClasses() const override
ArgumentLists getTemplateParameterLists() const override
Returns the template parameter lists that form the template declaration of this class.
void writeMemberList(OutputList &ol) const override
void writeMemberDeclarations(OutputList &ol, ClassDefSet &visitedClasses, MemberListType lt, const QCString &title, const QCString &subTitle=QCString(), bool showInline=FALSE, const ClassDef *inheritedFrom=nullptr, MemberListType lt2=MemberListType::Invalid(), bool invert=FALSE, bool showAlways=FALSE) const override
void writeBriefDescription(OutputList &ol, bool exampleFlag) const
void writeInlineClasses(OutputList &ol) const
void moveTo(Definition *) override
Definition classdef.cpp:970
const ExampleList & getExamples() const override
UsesClassList m_usesImplClassList
Definition classdef.cpp:479
void addListReferences() override
const ArgumentList & templateArguments() const override
Returns the template arguments of this class.
QCString m_inheritFileName
Definition classdef.cpp:422
void writeDetailedDocumentationBody(OutputList &ol) const
ClassDefImpl(const QCString &fileName, int startLine, int startColumn, const QCString &name, CompoundType ct, const QCString &ref=QCString(), const QCString &fName=QCString(), bool isSymbol=TRUE, bool isJavaEnum=FALSE)
Definition classdef.cpp:800
QCString generatedFromFiles() const override
const ClassDef * m_templateMaster
Definition classdef.cpp:492
void writeTagFile(TextStream &) const override
void endMemberDeclarations(OutputList &ol) const
bool m_membersMerged
Definition classdef.cpp:514
const MemberGroupList & getMemberGroups() const override
Returns the member groups defined for this class.
void sortMemberLists() override
const FileList & usedFiles() const override
void insertExplicitTemplateInstance(ClassDef *instance, const QCString &spec) override
void setTemplateArguments(const ArgumentList &al) override
void mergeCategory(ClassDef *category) override
void countMembers() override
void setClassSpecifier(TypeSpecifier spec) override
const MemberDef * getMemberByName(const QCString &) const override
Returns the member with the given name.
void reclassifyMember(MemberDefMutable *md, MemberType t) override
int countAdditionalInheritedMembers() const
void writePlainMemberDeclaration(OutputList &ol, MemberListType lt, bool inGroup, int indentLevel, const ClassDef *inheritedFrom, const QCString &inheritId) const
bool isFinal() const override
Returns TRUE if this class is marked as final.
void insertSubClass(ClassDef *, Protection p, Specifier s, const QCString &t=QCString()) override
void writeDocumentationForInnerClasses(OutputList &ol) const override
bool isUsedOnly() const override
QCString m_requiresClause
C++20 requires clause.
Definition classdef.cpp:549
void addQualifiers(const StringVector &qualifiers) override
void setTypeConstraints(const ArgumentList &al) override
bool isInterface() const override
Returns TRUE if this class represents an interface.
void writeSimpleMemberDocumentation(OutputList &ol, MemberListType lt) const
int countMemberDeclarations(MemberListType lt, const ClassDef *inheritedFrom, MemberListType lt2, bool invert, bool showAlways, ClassDefSet &visitedClasses) const override
void writeInlineDocumentation(OutputList &ol) const override
Write class documentation inside another container (i.e.
int countMembersIncludingGrouped(MemberListType lt, const ClassDef *inheritedFrom, bool additional) const override
bool isLocal() const override
Returns TRUE if this is a local class definition, see EXTRACT_LOCAL_CLASSES.
const BaseClassList & baseClasses() const override
Returns the list of base classes from which this class directly inherits.
void writeCollaborationGraph(OutputList &ol) const
void writeDeclarationLink(OutputList &ol, bool &found, const QCString &header, bool localNames) const override
void setRequiresClause(const QCString &req) override
void writeAuthorSection(OutputList &ol) const
void writeDetailedDescription(OutputList &ol, const QCString &pageType, bool exampleFlag, const QCString &title, const QCString &anchor=QCString()) const
TemplateNameMap m_templBaseClassNames
Definition classdef.cpp:489
const ConstraintClassList & templateTypeConstraints() const override
const UsesClassList & usedImplementationClasses() const override
std::unique_ptr< IncludeInfo > m_incInfo
Definition classdef.cpp:427
ClassDef * categoryOf() const override
Returns the class of which this is a category (Objective-C only).
bool isReference() const override
bool isPublished() const override
Returns TRUE if this class is marked as published.
bool m_isJavaEnum
Does this class represent a Java style enum?
Definition classdef.cpp:542
void writeDeclaration(OutputList &ol, const MemberDef *md, bool inGroup, int indentLevel, const ClassDef *inheritedFrom, const QCString &inheritId) const override
void addGroupedInheritedMembers(OutputList &ol, MemberListType lt, const ClassDef *inheritedFrom, const QCString &inheritId) const override
bool isFortran() const override
Returns TRUE if this class is implemented in Fortran.
BaseClassList m_inherits
Definition classdef.cpp:432
void writeMemberPages(OutputList &ol) const override
MemberNameInfoLinkedMap m_allMemberNameInfoLinkedMap
Definition classdef.cpp:450
void makeTemplateArgument(bool b=TRUE) override
void endMemberDocumentation(OutputList &ol) const
void writeDocumentation(OutputList &ol) const override
void writeMoreLink(OutputList &ol, const QCString &anchor) const
void setModuleDef(ModuleDef *mod) override
const BaseClassList & subClasses() const override
Returns the list of sub classes that directly derive from this class.
std::unique_ptr< ClassDef > deepCopy(const QCString &name) const override
Definition classdef.cpp:862
bool isSimple() const override
ModuleDef * m_moduleDef
Definition classdef.cpp:447
void hideDerivedVariablesInPython(ClassDefMutable *cls)
void addUsedInterfaceClasses(MemberDef *md, const QCString &typeStr)
bool hasCollaborationGraph() const override
void writeInheritedMemberDeclarations(OutputList &ol, ClassDefSet &visitedClasses, MemberListType lt, MemberListType lt2, const QCString &title, const ClassDef *inheritedFrom, bool invert, bool showAlways) const
void writeQuickMemberLinks(OutputList &ol, const MemberDef *md) const override
bool containsOverload(const MemberDef *md) const override
void getTitleForMemberListType(MemberListType type, QCString &title, QCString &subtitle) const
bool isJavaEnum() const override
void setCompoundType(CompoundType t) override
void insertMember(MemberDef *) override
int countInheritedDecMembers(MemberListType lt, const ClassDef *inheritedFrom, bool invert, bool showAlways, ClassDefSet &visitedClasses) const
bool m_isSimple
Is this a simple (non-nested) C structure?
Definition classdef.cpp:534
const ClassDef * tagLessReference() const override
bool isForwardDeclared() const override
Returns TRUE if this class represents a forward declaration of a template class.
CLASS_GRAPH_t m_typeInheritanceGraph
Definition classdef.cpp:554
int countInheritanceNodes() const
void setTemplateBaseClassNames(const TemplateNameMap &templateNames) override
void findSectionsInDocumentation() override
bool isTemplate() const override
Returns TRUE if this class is a template.
int countInheritsNodes() const
void addMembersToTemplateInstance(const ClassDef *cd, const ArgumentList &templateArguments, const QCString &templSpec) override
void mergeMembersFromBaseClasses(bool mergeVirtualBaseClass)
const MemberNameInfoLinkedMap & memberNameInfoLinkedMap() const override
Returns a dictionary of all members.
bool m_isAbstract
Definition classdef.cpp:508
StringVector m_qualifiers
Definition classdef.cpp:551
FileDef * m_fileDef
Definition classdef.cpp:444
const ClassDef * templateMaster() const override
Returns the template master of which this class is an instance.
const TemplateNameMap & getTemplateBaseClassNames() const override
ClassDef::CompoundType m_compType
Definition classdef.cpp:465
bool m_hasCollaborationGraph
Definition classdef.cpp:553
bool isExtension() const override
Returns TRUE if this class represents an Objective-C 2.0 extension (nameless category).
void addTypeConstraint(const QCString &typeConstraint, const QCString &type)
void setIncludeFile(FileDef *fd, const QCString &incName, bool local, bool force) override
bool isAbstract() const override
Returns TRUE if there is at least one pure virtual member in this class.
QCString getOutputFileBase() const override
void setGroupDefForAllMembers(GroupDef *g, Grouping::GroupPri_t pri, const QCString &fileName, int startLine, bool hasDocs) override
const IncludeInfo * includeInfo() const override
void setCategoryOf(ClassDef *cd) override
QCString m_className
Definition classdef.cpp:495
void addUsedClass(ClassDef *cd, const QCString &accessName, Protection prot) override
void addTypeConstraints() override
void setClassName(const QCString &name) override
QCString title() const override
bool visibleInParentsDeclList() const override
show this class in the declaration section of its parent?
const MemberLists & getMemberLists() const override
Returns the list containing the list of members sorted per type.
void overrideCollaborationGraph(bool e) override
bool isSealed() const override
Returns TRUE if this class is marked as sealed.
ClassLinkedRefMap m_innerClasses
Definition classdef.cpp:476
UsesClassList m_usedByImplClassList
Definition classdef.cpp:480
bool isSliceLocal() const override
ConstraintClassList m_constraintClassList
Definition classdef.cpp:482
void setIsStatic(bool b) override
int countInheritedByNodes() const
QCString getMemberListFileName() const override
Definition classdef.cpp:984
void setFileDef(FileDef *fd) override
void insertBaseClass(ClassDef *, const QCString &name, Protection p, Specifier s, const QCString &t=QCString()) override
Definition classdef.cpp:995
bool m_isTemplArg
Definition classdef.cpp:519
DefType definitionType() const override
Definition classdef.cpp:192
CodeSymbolType codeSymbolType() const override
QCString collaborationGraphFileName() const override
returns the file name to use for the collaboration graph
bool m_usedOnly
Reason of existence is a "use" relation.
Definition classdef.cpp:528
bool isCSharp() const override
Returns TRUE if this class is implemented in C#.
void computeAnchors() override
void writeIncludeFiles(OutputList &ol) const
QCString m_metaData
Definition classdef.cpp:546
QCString anchor() const override
void addInnerCompound(Definition *d) override
void setSubGrouping(bool enabled) override
void mergeMembers() override
void writeSummaryLinks(OutputList &ol) const override
void writeMemberGroups(OutputList &ol, bool showInline=FALSE) const
int isBaseClass(const ClassDef *bcd, bool followInstances, const QCString &templSpec) const override
Returns TRUE iff bcd is a direct or indirect base class of this class.
QCString requiresClause() const override
void writeAdditionalInheritedMembers(OutputList &ol) const
void writeNestedClasses(OutputList &ol, const QCString &title) const
void removeMemberFromLists(MemberDef *md) override
QCString displayName(bool includeScope=TRUE) const override
Definition classdef.cpp:989
bool isVisibleInHierarchy() const override
void writeMemberDocumentation(OutputList &ol, MemberListType lt, const QCString &title, bool showInline=FALSE) const
QCString m_memberListFileName
Definition classdef.cpp:416
bool isLinkable() const override
bool m_implicitTemplateInstance
Definition classdef.cpp:556
bool hasDocumentation() const override
ModuleDef * getModuleDef() const override
Returns the C++20 module in which this compound's definition can be found.
ArgumentList m_tempArgs
Definition classdef.cpp:453
void internalInsertMember(MemberDef *md, Protection prot, bool addToAllList)
void startMemberDeclarations(OutputList &ol) const
bool m_subGrouping
Definition classdef.cpp:525
void writeDocumentationContents(OutputList &ol, const QCString &pageTitle) const
bool hasExamples() const override
StringVector getQualifiers() const override
const MemberDef * isSmartPointer() const override
void updateBaseClasses(const BaseClassList &bcd) override
Update the list of base classes to the one passed.
CLASS_GRAPH_t hasInheritanceGraph() const override
MemberList * getMemberList(MemberListType lt) const override
Returns the members in the list identified by lt.
void setUsedOnly(bool b) override
Protection protection() const override
Return the protection level (Public,Protected,Private) in which this compound was found.
const ArgumentList & typeConstraints() const override
void showUsedFiles(OutputList &ol) const
const Definition * findInnerCompound(const QCString &name) const override
ClassDef * insertTemplateInstance(const QCString &fileName, int startLine, int startColumn, const QCString &templSpec, bool &freshInstance) override
bool isEmbeddedInOuterScope() const override
void sortAllMembersList() override
CompoundType compoundType() const override
Returns the type of compound this is, i.e.
bool isAccessibleMember(const MemberDef *md) const override
returns TRUE iff md is a member of this class or of the the public/protected members of a base class
bool isImplicitTemplateInstance() const override
bool hasNonReferenceSuperClass() const override
void setTemplateMaster(const ClassDef *tm) override
QCString inheritanceGraphFileName() const override
returns the file name to use for the inheritance graph
void startMemberDocumentation(OutputList &ol) const
QCString getSourceFileBase() const override
void setProtection(Protection p) override
bool hasDetailedDescription() const override
returns TRUE if this class has a non-empty detailed description
virtual void setGroupDefForAllMembers(GroupDef *g, Grouping::GroupPri_t pri, const QCString &fileName, int startLine, bool hasDocs)=0
virtual void setTemplateArguments(const ArgumentList &al)=0
virtual void setTemplateMaster(const ClassDef *tm)=0
virtual void setImplicitTemplateInstance(bool b)=0
virtual void addMemberToTemplateInstance(const MemberDef *md, const ArgumentList &templateArguments, const QCString &templSpec)=0
virtual void insertUsedFile(const FileDef *)=0
virtual void setUsedOnly(bool b)=0
virtual void setCategoryOf(ClassDef *cd)=0
virtual void addMembersToTemplateInstance(const ClassDef *cd, const ArgumentList &templateArguments, const QCString &templSpec)=0
virtual void mergeMembers()=0
Class representing a built-in class diagram.
Definition diagram.h:31
const QCString & name() const override
const Definition * getAlias() const
const Definition * getScope() const
DefinitionAliasMixin(const Definition *scope, const Definition *alias)
The common base class of all entity definitions found in the sources.
Definition definition.h:76
virtual QCString docFile() const =0
virtual const QCString & localName() const =0
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
virtual int docLine() const =0
virtual QCString getDefFileName() const =0
virtual bool isLinkable() const =0
virtual int getDefLine() const =0
virtual DefType definitionType() const =0
virtual QCString anchor() const =0
virtual int inbodyLine() const =0
virtual int briefLine() const =0
virtual bool hasDocumentation() const =0
virtual bool isLinkableInProject() const =0
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
virtual bool isAnonymous() const =0
virtual bool isHidden() const =0
virtual const Definition * findInnerCompound(const QCString &name) const =0
virtual QCString getReference() const =0
virtual QCString getSourceFileBase() const =0
virtual QCString documentation() const =0
virtual QCString qualifiedName() const =0
virtual QCString displayName(bool includeScope=TRUE) const =0
virtual bool isArtificial() const =0
virtual QCString briefFile() const =0
virtual CodeSymbolType codeSymbolType() const =0
virtual QCString getOutputFileBase() const =0
virtual Definition * getOuterScope() const =0
virtual bool isReference() const =0
virtual QCString inbodyDocumentation() const =0
virtual QCString inbodyFile() const =0
virtual const QCString & name() const =0
bool isReference() const override
const QCString & name() const override
void writeSourceDef(OutputList &ol) const override
QCString inbodyFile() const override
QCString getDefFileName() const override
void writeNavigationPath(OutputList &ol) const override
bool hasBriefDescription() const override
QCString docFile() const override
QCString briefFile() const override
QCString qualifiedName() const override
QCString id() const override
void setOuterScope(Definition *def) override
void setReference(const QCString &r) override
QCString getSourceFileBase() const override
const RefItemVector & xrefListItems() const override
QCString briefDescription(bool abbreviate=FALSE) const override
Definition * getOuterScope() const override
QCString getReference() const override
DefinitionMixin(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const char *b=nullptr, const char *d=nullptr, bool isSymbol=TRUE)
const QCString & localName() const override
const GroupList & partOfGroups() const override
const FileDef * getBodyDef() const override
int getStartBodyLine() const override
QCString inbodyDocumentation() const override
QCString documentation() const override
void writeDocAnchorsToTagFile(TextStream &fs) const override
bool hasDocumentation() const override
SrcLangExt getLanguage() const override
virtual void setHidden(bool b)=0
virtual void addInnerCompound(Definition *d)=0
virtual void setLanguage(SrcLangExt lang)=0
virtual void setOuterScope(Definition *d)=0
virtual void setArtificial(bool b)=0
Representation of a class inheritance or dependency graph.
bool isTooBig() const
bool isTrivial() const
int numNodes() const
static bool suppressDocWarnings
Definition doxygen.h:132
static ClassLinkedMap * classLinkedMap
Definition doxygen.h:96
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
static ClassLinkedMap * hiddenClassLinkedMap
Definition doxygen.h:97
static bool generatingXmlOutput
Definition doxygen.h:136
static MemberNameLinkedMap * memberNameLinkedMap
Definition doxygen.h:111
A model of a file symbol.
Definition filedef.h:99
Minimal replacement for QFileInfo.
Definition fileinfo.h:23
bool exists() const
Definition fileinfo.cpp:30
std::string absFilePath() const
Definition fileinfo.cpp:101
A model of a group of symbols.
Definition groupdef.h:52
virtual bool addClass(ClassDef *def)=0
virtual bool insertMember(MemberDef *def, bool docOnly=FALSE)=0
static LayoutDocManager & instance()
Returns a reference to this singleton.
Definition layout.cpp:1435
bool del(const QCString &key)
Definition linkedmap.h:183
T * add(const char *k, Args &&... args)
Definition linkedmap.h:90
const T * find(const std::string &key) const
Definition linkedmap.h:47
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
virtual QCString typeString() const =0
virtual bool isSignal() const =0
virtual bool isDestructor() const =0
virtual bool isExplicit() const =0
virtual bool isObjCMethod() const =0
virtual bool isMaybeVoid() const =0
virtual bool isConstructor() const =0
virtual bool isFriend() const =0
virtual bool isRelated() const =0
virtual const ClassDef * getClassDef() const =0
virtual bool isOverride() const =0
virtual bool isTypedef() const =0
virtual ClassDef * category() const =0
virtual bool isSlot() const =0
virtual const FileDef * getFileDef() const =0
virtual bool isInline() const =0
virtual const ArgumentList & argumentList() const =0
virtual bool isMaybeAmbiguous() const =0
virtual VhdlSpecifier getVhdlSpecifiers() const =0
virtual bool isFunction() const =0
virtual bool isAttribute() const =0
virtual int getMemberGroupId() const =0
virtual bool isStatic() const =0
virtual bool isMaybeDefault() const =0
virtual bool isRemovable() const =0
virtual bool isConstrained() const =0
virtual bool isReadonly() const =0
virtual bool isBound() const =0
virtual bool isThreadLocal() const =0
virtual ClassDef * getClassDefOfAnonymousType() const =0
virtual std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const =0
virtual bool isTransient() const =0
virtual Protection protection() const =0
virtual TypeSpecifier getMemberSpecifiers() const =0
virtual bool isOptional() const =0
virtual bool isEnumerate() const =0
virtual MemberType memberType() const =0
virtual std::unique_ptr< MemberDef > deepCopy() const =0
virtual QCString memberTypeName() const =0
virtual bool isVariable() const =0
virtual QCString argsString() const =0
virtual Specifier virtualness(int count=0) const =0
virtual bool isUNOProperty() const =0
virtual bool isFinal() const =0
virtual bool isMutable() const =0
virtual bool isEnumValue() const =0
virtual void setMemberType(MemberType t)=0
virtual void setSectionList(const Definition *container, const MemberList *sl)=0
virtual void setCategory(ClassDef *)=0
virtual void setGroupDef(GroupDef *gd, Grouping::GroupPri_t pri, const QCString &fileName, int startLine, bool hasDocs, MemberDef *member=nullptr)=0
virtual void setCategoryRelation(const MemberDef *)=0
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:125
void writeDeclarations(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, const QCString &title, const QCString &subtitle, bool showEnumValues=FALSE, bool showInline=FALSE, const ClassDef *inheritedFrom=nullptr, MemberListType lt=MemberListType::PubMethods(), bool showSectionTitle=true) const
Writes the list of members to the output.
void writeTagFile(TextStream &, bool useQualifiedName=false, bool showNamespaceMembers=true)
void writePlainDeclarations(OutputList &ol, bool inGroup, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, int indentLevel, const ClassDef *inheritedFrom, const QCString &inheritId) const
void setAnonymousEnumType()
int countInheritableMembers(const ClassDef *inheritedFrom) const
void writeSimpleDocumentation(OutputList &ol, const Definition *container) const
MemberListType listType() const
Definition memberlist.h:130
void writeDocumentation(OutputList &ol, const QCString &scopeName, const Definition *container, const QCString &title, const QCString &anchor, bool showEnumValues=FALSE, bool showInline=FALSE) const
int numDecMembers(const ClassDef *inheritedFrom) const
Definition memberlist.h:133
bool declVisible() const
Wrapper class for the MemberListType type.
Definition types.h:346
static MemberListType Invalid()
Definition types.h:371
constexpr const char * toLabel() const
Definition types.h:402
constexpr bool isInvalid() const
Definition types.h:372
void push_back(Ptr &&p)
Definition membername.h:54
bool empty() const
Definition membername.h:135
void push_back(Ptr &&p)
Definition membername.h:141
iterator begin()
Definition membername.h:131
iterator end()
Definition membername.h:132
typename Vec::iterator iterator
Definition membername.h:125
iterator erase(iterator pos)
Definition membername.h:142
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:315
void writeDoc(const IDocNodeAST *ast, const Definition *ctx, const MemberDef *md, int sectionLevel=-1)
Definition outputlist.h:383
void endTextBlock(bool paraBreak=FALSE)
Definition outputlist.h:672
void endIndent()
Definition outputlist.h:584
void writeString(const QCString &text)
Definition outputlist.h:411
void startMemberDeclaration()
Definition outputlist.h:569
void startMemberDoc(const QCString &clName, const QCString &memName, const QCString &anchor, const QCString &title, int memCount, int memTotal, bool showInline)
Definition outputlist.h:531
void startMemberDocName(bool align)
Definition outputlist.h:680
void startClassDiagram()
Definition outputlist.h:594
void startItemList()
Definition outputlist.h:429
void disable(OutputType o)
void endMemberDocName()
Definition outputlist.h:682
void endMemberDoc(bool hasArgs)
Definition outputlist.h:535
void writeRuler()
Definition outputlist.h:521
void startGroupHeader(const QCString &id=QCString(), int extraLevels=0)
Definition outputlist.h:453
void enable(OutputType o)
void endContents()
Definition outputlist.h:620
void endMemberDescription()
Definition outputlist.h:567
void writeObjectLink(const QCString &ref, const QCString &file, const QCString &anchor, const QCString &name)
Definition outputlist.h:439
void startMemberDescription(const QCString &anchor, const QCString &inheritId=QCString(), bool typ=false)
Definition outputlist.h:565
void endCompoundTemplateParams()
Definition outputlist.h:503
void docify(const QCString &s)
Definition outputlist.h:437
void generateDoc(const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, const DocOptions &options)
void startIndent()
Definition outputlist.h:582
void startParagraph(const QCString &classDef=QCString())
Definition outputlist.h:407
void endDescForItem()
Definition outputlist.h:549
void startTextBlock(bool dense=FALSE)
Definition outputlist.h:670
void endExamples()
Definition outputlist.h:580
void endParagraph()
Definition outputlist.h:409
void addIndexItem(const QCString &s1, const QCString &s2)
Definition outputlist.h:590
void startExamples()
Definition outputlist.h:578
void startMemberSections()
Definition outputlist.h:461
void startMemberList()
Definition outputlist.h:481
void endTextLink()
Definition outputlist.h:444
void startItemListItem()
Definition outputlist.h:457
void endItemListItem()
Definition outputlist.h:459
void startBold()
Definition outputlist.h:561
void endMemberItem(OutputGenerator::MemberItemType type)
Definition outputlist.h:495
void writeSynopsis()
Definition outputlist.h:592
void startTypewriter()
Definition outputlist.h:449
void pushGeneratorState()
void insertMemberAlign(bool templ=FALSE)
Definition outputlist.h:517
void startDescForItem()
Definition outputlist.h:547
void disableAllBut(OutputType o)
void popGeneratorState()
void writeSummaryLink(const QCString &file, const QCString &anchor, const QCString &title, bool first)
Definition outputlist.h:614
void writeAnchor(const QCString &fileName, const QCString &name)
Definition outputlist.h:523
void endBold()
Definition outputlist.h:563
void endGroupHeader(int extraLevels=0)
Definition outputlist.h:455
void endClassDiagram(const ClassDiagram &d, const QCString &f, const QCString &n)
Definition outputlist.h:596
void endLabels()
Definition outputlist.h:742
void endQuickIndices()
Definition outputlist.h:604
void writePageOutline()
Definition outputlist.h:616
void endDotGraph(DotClassGraph &g)
Definition outputlist.h:650
void endItemList()
Definition outputlist.h:431
void startDotGraph()
Definition outputlist.h:648
void writeLabel(const QCString &l, bool isLast)
Definition outputlist.h:740
void startLabels()
Definition outputlist.h:738
void startContents()
Definition outputlist.h:618
void startCompoundTemplateParams()
Definition outputlist.h:501
void endMemberDeclaration(const QCString &anchor, const QCString &inheritId)
Definition outputlist.h:571
void enableAll()
void endMemberHeader()
Definition outputlist.h:471
void startMemberItem(const QCString &anchor, OutputGenerator::MemberItemType type, const QCString &id=QCString())
Definition outputlist.h:493
void endTypewriter()
Definition outputlist.h:451
void lineBreak(const QCString &style=QCString())
Definition outputlist.h:559
void parseText(const QCString &textStr)
void startTextLink(const QCString &file, const QCString &anchor)
Definition outputlist.h:442
void startMemberHeader(const QCString &anchor, int typ=2)
Definition outputlist.h:469
void endMemberSections()
Definition outputlist.h:463
This is an alternative implementation of QCString.
Definition qcstring.h:101
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString & prepend(const char *s)
Definition qcstring.h:422
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:166
bool startsWith(const char *s) const
Definition qcstring.h:507
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:241
QCString lower() const
Definition qcstring.h:249
bool endsWith(const char *s) const
Definition qcstring.h:524
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:163
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:260
QCString right(size_t len) const
Definition qcstring.h:234
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:172
QCString left(size_t len) const
Definition qcstring.h:229
void clear()
Definition qcstring.h:182
ClassDefMutable * resolveClassMutable(const Definition *scope, const QCString &name, bool mayBeUnlinkable=false, bool mayBeHidden=false)
Wrapper around resolveClass that returns a mutable interface to the class object or a nullptr if the ...
Implements TextGeneratorIntf for an OutputDocInterface stream.
Definition util.h:77
Text streaming class that buffers data.
Definition textstream.h:36
Wrapper class for a number of boolean properties.
Definition types.h:654
@ ARCHITECTURECLASS
Definition vhdldocgen.h:77
static QCString getClassName(const ClassDef *)
static QCString getProtectionName(int prot)
static void writeInlineClassLink(const ClassDef *, OutputList &ol)
static void writeVhdlDeclarations(const MemberList *, OutputList &, const GroupDef *, const ClassDef *, const FileDef *, const NamespaceDef *, const ModuleDef *)
static VhdlClasses convert(Protection prot)
Definition vhdldocgen.h:80
static QCString getClassTitle(const ClassDef *)
static QCString makeQualifiedNameWithTemplateParameters(const ClassDef *cd, const ArgumentLists *actualParams, uint32_t *actualParamIndex)
Definition classdef.cpp:56
static QCString getCompoundTypeString(SrcLangExt lang, ClassDef::CompoundType compType, bool isJavaEnum)
Definition classdef.cpp:146
ClassDefMutable * toClassDefMutable(Definition *d)
static bool hasNonReferenceSuperClassRec(const ClassDef *cd, int level)
static QCString makeDisplayName(const ClassDef *cd, bool includeScope)
Definition classdef.cpp:107
int minClassDistance(const ClassDef *cd, const ClassDef *bcd, int level)
static bool isStandardFunc(const MemberDef *md)
ClassDef * getClass(const QCString &n)
std::unique_ptr< ClassDef > createClassDefAlias(const Definition *newScope, const ClassDef *cd)
Definition classdef.cpp:788
static void writeInheritanceSpecifier(OutputList &ol, const BaseClassDef &bcd)
bool classHasVisibleRoot(const BaseClassList &bcl)
std::unique_ptr< ClassDef > createClassDef(const QCString &fileName, int startLine, int startColumn, const QCString &name, ClassDef::CompoundType ct, const QCString &ref, const QCString &fName, bool isSymbol, bool isJavaEnum)
Factory method to create a new ClassDef object.
Definition classdef.cpp:559
static void searchTemplateSpecs(const Definition *d, ArgumentLists &result, QCString &name, SrcLangExt lang)
bool classVisibleInIndex(const ClassDef *cd)
ClassDef * toClassDef(Definition *d)
Protection classInheritedProtectionLevel(const ClassDef *cd, const ClassDef *bcd, Protection prot, int level)
bool classHasVisibleChildren(const ClassDef *cd)
std::vector< BaseClassDef > BaseClassList
Definition classdef.h:81
std::unordered_set< const ClassDef * > ClassDefSet
Definition classdef.h:95
std::map< std::string, int > TemplateNameMap
Definition classdef.h:93
std::vector< TemplateInstanceDef > TemplateInstanceList
Definition classdef.h:91
#define Config_getInt(name)
Definition config.h:34
#define Config_getList(name)
Definition config.h:38
#define Config_getBool(name)
Definition config.h:33
#define Config_getString(name)
Definition config.h:32
#define Config_getEnum(name)
Definition config.h:35
#define NON_COPYABLE(cls)
Macro to help implementing the rule of 5 for a non-copyable & movable class.
Definition construct.h:37
std::set< std::string > StringSet
Definition containers.h:31
std::vector< std::string > StringVector
Definition containers.h:33
std::unique_ptr< ArgumentList > stringToArgumentList(SrcLangExt lang, const QCString &argsString, QCString *extraTypeChars=nullptr)
Definition defargs.l:809
Definition * toDefinition(DefinitionMutable *dm)
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:47
#define AUTO_TRACE(...)
Definition docnode.cpp:46
#define AUTO_TRACE_EXIT(...)
Definition docnode.cpp:48
void docFindSections(const QCString &input, const Definition *d, const QCString &fileName)
IDocNodeASTPtr validatingParseDoc(IDocParser &parserIntf, const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &input, const DocOptions &options)
IDocParserPtr createDocParser()
factory function to create a parser
Definition docparser.cpp:55
@ Collaboration
Definition dotgraph.h:31
@ Inheritance
Definition dotgraph.h:31
static bool isSpecialization(const ArgumentLists &srcTempArgLists, const ArgumentLists &dstTempArgLists)
Definition doxygen.cpp:5919
static void writeTagFile()
QCString includeClose(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:86
QCString includeStatement(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:56
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1954
QCString includeOpen(SrcLangExt lang, IncludeKind kind)
Definition filedef.cpp:73
@ IncludeLocal
Definition filedef.h:50
@ IncludeSystem
Definition filedef.h:49
void startTitle(OutputList &ol, const QCString &fileName, const DefinitionMutable *def)
Definition index.cpp:384
void endFile(OutputList &ol, bool skipNavIndex, bool skipEndContents, const QCString &navPath)
Definition index.cpp:427
void endTitle(OutputList &ol, const QCString &fileName, const QCString &name)
Definition index.cpp:394
void startFile(OutputList &ol, const QCString &name, bool isSource, const QCString &manName, const QCString &title, HighlightedItem hli, bool additionalIndices, const QCString &altSidebarName, int hierarchyLevel, const QCString &allMembersFile)
Definition index.cpp:401
void endFileWithNavPath(OutputList &ol, const DefinitionMutable *d, bool showPageNavigation)
Definition index.cpp:448
HighlightedItem
Definition index.h:59
@ InterfaceVisible
Definition index.h:89
@ ExceptionVisible
Definition index.h:91
Translator * theTranslator
Definition language.cpp:71
MemberDefMutable * toMemberDefMutable(Definition *d)
void combineDeclarationAndDefinition(MemberDefMutable *mdec, MemberDefMutable *mdef)
#define warn_uncond(fmt,...)
Definition message.h:122
#define warn(file, line, fmt,...)
Definition message.h:97
#define msg(fmt,...)
Definition message.h:94
#define err(fmt,...)
Definition message.h:127
ModuleDef * toModuleDef(Definition *d)
int qstricmp(const char *s1, const char *s2)
Definition qcstring.cpp:447
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:482
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34
std::vector< RefItem * > RefItemVector
Definition reflist.h:133
Web server based search engine.
This class contains the information about the argument of a function or template.
Definition arguments.h:27
QCString type
Definition arguments.h:42
QCString name
Definition arguments.h:44
QCString defval
Definition arguments.h:46
Class that contains information about an inheritance relation.
Definition classdef.h:55
ClassDef * classDef
Class definition that this relation inherits from.
Definition classdef.h:60
QCString templSpecifiers
Template arguments used for the base class.
Definition classdef.h:78
Specifier virt
Virtualness of the inheritance relation: Normal, or Virtual.
Definition classdef.h:75
Protection prot
Protection level of the inheritance relation: Public, Protected, or Private.
Definition classdef.h:70
Data associated with an example.
Definition example.h:29
GroupPri_t
Grouping priority.
Definition types.h:230
Class representing the data associated with a #include statement.
Definition filedef.h:75
Represents of a member declaration list with configurable title and subtitle.
Definition layout.h:112
QCString title(SrcLangExt lang) const
Definition layout.cpp:1786
MemberListType type
Definition layout.h:118
QCString subtitle(SrcLangExt lang) const
Definition layout.cpp:1791
Represents of a member definition list with configurable title.
Definition layout.h:132
MemberListType type
Definition layout.h:137
QCString title(SrcLangExt lang) const
Definition layout.cpp:1798
Definition layout.h:102
QCString title(SrcLangExt lang) const
Definition layout.cpp:1779
This file contains a number of basic enums and types.
CodeSymbolType
Definition types.h:481
MemberType
Definition types.h:552
@ Enumeration
Definition types.h:557
@ EnumValue
Definition types.h:558
@ Interface
Definition types.h:565
@ Variable
Definition types.h:555
@ Property
Definition types.h:563
@ Typedef
Definition types.h:556
@ Function
Definition types.h:554
@ Service
Definition types.h:566
Protection
Definition types.h:32
SrcLangExt
Definition types.h:207
Specifier
Definition types.h:80
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:576
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5107
QCString insertTemplateSpecifierInScope(const QCString &scope, const QCString &templ)
Definition util.cpp:3667
bool protectionLevelVisible(Protection prot)
Definition util.cpp:5849
QCString convertToHtml(const QCString &s, bool keepEntities)
Definition util.cpp:3884
void writeTypeConstraints(OutputList &ol, const Definition *d, const ArgumentList &al)
Definition util.cpp:5355
QCString tempArgListToString(const ArgumentList &al, SrcLangExt lang, bool includeDefault)
Definition util.cpp:1244
void addRefItem(const RefItemVector &sli, const QCString &key, const QCString &prefix, const QCString &name, const QCString &title, const QCString &args, const Definition *scope)
Definition util.cpp:4726
void addGroupListToTitle(OutputList &ol, const Definition *d)
Definition util.cpp:4813
QCString demangleCSharpGenericName(const QCString &name, const QCString &templArgs)
Definition util.cpp:6833
QCString removeAnonymousScopes(const QCString &str)
Definition util.cpp:170
void createSubDirs(const Dir &d)
Definition util.cpp:3561
bool matchArguments2(const Definition *srcScope, const FileDef *srcFileScope, const ArgumentList *srcAl, const Definition *dstScope, const FileDef *dstFileScope, const ArgumentList *dstAl, bool checkCV, SrcLangExt lang)
Definition util.cpp:1956
QCString stripScope(const QCString &name)
Definition util.cpp:3700
QCString inlineTemplateArgListToDoc(const ArgumentList &al)
Definition util.cpp:1172
QCString stripExtension(const QCString &fName)
Definition util.cpp:4845
static QCString stripFromPath(const QCString &p, const StringVector &l)
Definition util.cpp:307
QCString convertNameToFile(const QCString &name, bool allowDots, bool allowUnderscore)
Definition util.cpp:3425
QCString convertToXML(const QCString &s, bool keepEntities)
Definition util.cpp:3833
EntryType guessSection(const QCString &name)
Definition util.cpp:347
void convertProtectionLevel(MemberListType inListType, Protection inProt, MemberListType *outListType1, MemberListType *outListType2)
Computes for a given list type inListType, which are the the corresponding list type(s) in the base c...
Definition util.cpp:6139
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:5809
void writeMarkerList(OutputList &ol, const std::string &markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)
Definition util.cpp:1101
void linkifyText(const TextGeneratorIntf &out, const Definition *scope, const FileDef *fileScope, const Definition *self, const QCString &text, bool autoBreak, bool external, bool keepSpaces, int indentLevel)
Definition util.cpp:902
QCString convertToId(const QCString &s)
Definition util.cpp:3793
void writeExamples(OutputList &ol, const ExampleList &list)
Definition util.cpp:1125
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:4823
A bunch of utility functions.