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