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