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