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