Doxygen
Loading...
Searching...
No Matches
memberdef.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * Copyright (C) 1997-2015 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
17#include <stdio.h>
18#include <assert.h>
19#include <mutex>
20
21#include "md5.h"
22#include "memberdef.h"
23#include "membername.h"
24#include "doxygen.h"
25#include "util.h"
26#include "code.h"
27#include "message.h"
28#include "htmlhelp.h"
29#include "language.h"
30#include "outputlist.h"
31#include "example.h"
32#include "membergroup.h"
33#include "groupdef.h"
34#include "defargs.h"
35#include "docparser.h"
36#include "dot.h"
37#include "dotcallgraph.h"
38#include "searchindex.h"
39#include "parserintf.h"
40#include "vhdldocgen.h"
41#include "arguments.h"
42#include "memberlist.h"
43#include "namespacedef.h"
44#include "moduledef.h"
45#include "filedef.h"
46#include "config.h"
47#include "definitionimpl.h"
48#include "regex.h"
49#include "trace.h"
50
51//-----------------------------------------------------------------------------
52
53class MemberDefImpl final : public DefinitionMixin<MemberDefMutable>
54{
55 public:
56 MemberDefImpl(const QCString &defFileName,int defLine,int defColumn,
57 const QCString &type,const QCString &name,const QCString &args,
58 const QCString &excp,Protection prot,Specifier virt,bool stat,
59 Relationship related,MemberType t,const ArgumentList &tal,
60 const ArgumentList &al,const QCString &metaData);
61 ~MemberDefImpl() override = default;
62 NON_COPYABLE(MemberDefImpl)
63
64 DefType definitionType() const override { return TypeMember; }
65 MemberDef *resolveAlias() override { return this; }
66 const MemberDef *resolveAlias() const override { return this; }
67 CodeSymbolType codeSymbolType() const override;
68 std::unique_ptr<MemberDef> deepCopy() const override;
69 void moveTo(Definition *) override;
70 QCString getOutputFileBase() const override;
71 QCString getReference() const override;
72 QCString anchor() const override;
73 QCString declaration() const override;
74 QCString definition() const override;
75 QCString typeString() const override;
76 QCString argsString() const override;
77 QCString excpString() const override;
78 QCString bitfieldString() const override;
79 QCString extraTypeChars() const override;
80 const QCString &initializer() const override;
81 int initializerLines() const override;
82 TypeSpecifier getMemberSpecifiers() const override;
83 VhdlSpecifier getVhdlSpecifiers() const override;
84 const MemberList *getSectionList(const Definition *) const override;
85 QCString displayDefinition() const override;
86 const ClassDef *getClassDef() const override;
87 ClassDef *getClassDef() override;
88 const FileDef *getFileDef() const override;
89 FileDef *getFileDef() override;
90 const NamespaceDef* getNamespaceDef() const override;
91 NamespaceDef* getNamespaceDef() override;
92 const GroupDef *getGroupDef() const override;
93 GroupDef *getGroupDef() override;
94 const ModuleDef *getModuleDef() const override;
95 ClassDef *accessorClass() const override;
96 QCString getReadAccessor() const override;
97 QCString getWriteAccessor() const override;
98 Grouping::GroupPri_t getGroupPri() const override;
99 QCString getGroupFileName() const override;
100 int getGroupStartLine() const override;
101 bool getGroupHasDocs() const override;
102 QCString qualifiedName() const override;
103 QCString objCMethodName(bool localLink,bool showStatic) const override;
104 Protection protection() const override;
105 Specifier virtualness(int count=0) const override;
106 MemberType memberType() const override;
107 QCString memberTypeName() const override;
108 bool isSignal() const override;
109 bool isSlot() const override;
110 bool isVariable() const override;
111 bool isEnumerate() const override;
112 bool isEnumValue() const override;
113 bool isTypedef() const override;
114 bool isSequence() const override;
115 bool isDictionary() const override;
116 bool isFunction() const override;
117 bool isFunctionPtr() const override;
118 bool isDefine() const override;
119 bool isFriend() const override;
120 bool isDCOP() const override;
121 bool isProperty() const override;
122 bool isEvent() const override;
123 bool isRelated() const override;
124 bool isForeign() const override;
125 bool isStatic() const override;
126 bool isInline() const override;
127 bool isExplicit() const override;
128 bool isMutable() const override;
129 bool isThreadLocal() const override;
130 bool isGettable() const override;
131 bool isPrivateGettable() const override;
132 bool isProtectedGettable() const override;
133 bool isSettable() const override;
134 bool isPrivateSettable() const override;
135 bool isProtectedSettable() const override;
136 bool isReadable() const override;
137 bool isWritable() const override;
138 bool isAddable() const override;
139 bool isRemovable() const override;
140 bool isRaisable() const override;
141 bool isFinal() const override;
142 bool isAbstract() const override;
143 bool isOverride() const override;
144 bool isInitonly() const override;
145 bool isOptional() const override;
146 bool isRequired() const override;
147 bool isNonAtomic() const override;
148 bool isCopy() const override;
149 bool isAssign() const override;
150 bool isRetain() const override;
151 bool isWeak() const override;
152 bool isStrong() const override;
153 bool isEnumStruct() const override;
154 bool isUnretained() const override;
155 bool isNew() const override;
156 bool isSealed() const override;
157 bool isImplementation() const override;
158 bool isExternal() const override;
159 bool isTypeAlias() const override;
160 bool isDefault() const override;
161 bool isDelete() const override;
162 bool isNoExcept() const override;
163 bool isAttribute() const override;
164 bool isUNOProperty() const override;
165 bool isReadonly() const override;
166 bool isBound() const override;
167 bool isConstrained() const override;
168 bool isTransient() const override;
169 bool isMaybeVoid() const override;
170 bool isMaybeDefault() const override;
171 bool isMaybeAmbiguous() const override;
172 bool isPublished() const override;
173 bool isTemplateSpecialization() const override;
174 bool isObjCMethod() const override;
175 bool isObjCProperty() const override;
176 bool isCSharpProperty() const override;
177 bool isConstructor() const override;
178 bool isDestructor() const override;
179 bool hasOneLineInitializer() const override;
180 bool hasMultiLineInitializer() const override;
181 bool isCallable() const override;
182 bool isStrongEnumValue() const override;
183 bool livesInsideEnum() const override;
184 bool isSliceLocal() const override;
185 bool isNoDiscard() const override;
186 bool isConstExpr() const override;
187 bool isConstEval() const override;
188 bool isConstInit() const override;
189 int numberOfFlowKeyWords() const override;
190 bool isFriendToHide() const override;
191 bool isNotFriend() const override;
192 bool isFunctionOrSignalSlot() const override;
193 bool isRelatedOrFriend() const override;
194 bool isLinkableInProject() const override;
195 bool isLinkable() const override;
196 bool hasDocumentation() const override;
197 bool hasUserDocumentation() const override;
198 bool isDeleted() const override;
199 bool isBriefSectionVisible() const override;
200 bool isDetailedSectionVisible(MemberListContainer container) const override;
201 bool hasDetailedDescription() const override;
202 bool isFriendClass() const override;
203 bool isDocumentedFriendClass() const override;
204 const MemberDef *reimplements() const override;
205 const MemberVector &reimplementedBy() const override;
206 bool isReimplementedBy(const ClassDef *cd) const override;
207 ClassDef *relatedAlso() const override;
208 bool hasDocumentedEnumValues() const override;
209 const MemberDef *getAnonymousEnumType() const override;
210 bool isDocsForDefinition() const override;
211 const MemberDef *getEnumScope() const override;
212 const MemberVector &enumFieldList() const override;
213 void setEnumBaseType(const QCString &type) override;
214 QCString enumBaseType() const override;
215 bool hasExamples() const override;
216 const ExampleList &getExamples() const override;
217 bool isPrototype() const override;
218 const ArgumentList &argumentList() const override;
219 const ArgumentList &declArgumentList() const override;
220 const ArgumentList &templateArguments() const override;
221 const ArgumentLists &definitionTemplateParameterLists() const override;
222 std::optional<ArgumentList> formalTemplateArguments() const override;
223 int getMemberGroupId() const override;
224 MemberGroup *getMemberGroup() const override;
225 bool fromAnonymousScope() const override;
226 MemberDef *fromAnonymousMember() const override;
227 bool hasCallGraph() const override;
228 bool hasCallerGraph() const override;
229 bool hasReferencesRelation() const override;
230 bool hasReferencedByRelation() const override;
231 bool hasEnumValues() const override;
232 bool hasInlineSource() const override;
233 bool isDocTransferDone() const override;
234 QCString sourceRefName() const override;
235 const MemberDef *templateMaster() const override;
236 QCString getScopeString() const override;
237 ClassDef *getClassDefOfAnonymousType() const override;
238 bool isTypedefValCached() const override;
239 const ClassDef *getCachedTypedefVal() const override;
240 QCString getCachedTypedefTemplSpec() const override;
241 QCString getCachedResolvedTypedef() const override;
242 MemberDef *memberDefinition() const override;
243 MemberDef *memberDeclaration() const override;
244 const MemberDef *inheritsDocsFrom() const override;
245 const MemberDef *getGroupAlias() const override;
246 ClassDef *category() const override;
247 const MemberDef *categoryRelation() const override;
248 QCString displayName(bool=TRUE) const override;
249 QCString getDeclType() const override;
250 StringVector getLabels(const Definition *container) const override;
251 const ArgumentList &typeConstraints() const override;
252 QCString requiresClause() const override;
253 QCString documentation() const override;
254 QCString briefDescription(bool abbr=FALSE) const override;
255 QCString fieldType() const override;
256 bool isReference() const override;
257 QCString getDeclFileName() const override;
258 int getDeclLine() const override;
259 int getDeclColumn() const override;
260 void setMemberType(MemberType t) override;
261 void setDefinition(const QCString &d) override;
262 void setFileDef(FileDef *fd) override;
263 void setAnchor() override;
264 void setProtection(Protection p) override;
265 void setMemberSpecifiers(TypeSpecifier s) override;
266 void setVhdlSpecifiers(VhdlSpecifier s) override;
267 void mergeMemberSpecifiers(TypeSpecifier s) override;
268 void setInitializer(const QCString &i) override;
269 void setBitfields(const QCString &s) override;
270 void setMaxInitLines(int lines) override;
271 void setMemberClass(ClassDef *cd) override;
272 void setSectionList(const Definition *container,const MemberList *sl) override;
273 void setGroupDef(GroupDef *gd,Grouping::GroupPri_t pri,
274 const QCString &fileName,int startLine,bool hasDocs,
275 MemberDef *member=nullptr) override;
276 void setReadAccessor(const QCString &r) override;
277 void setWriteAccessor(const QCString &w) override;
278 void setTemplateSpecialization(bool b) override;
279 void makeRelated() override;
280 void makeForeign() override;
281 void setInheritsDocsFrom(const MemberDef *md) override;
282 void setTagInfo(const TagInfo *i) override;
283 void setArgsString(const QCString &as) override;
284 void setReimplements(MemberDef *md) override;
285 void insertReimplementedBy(MemberDef *md) override;
286 void setRelatedAlso(ClassDef *cd) override;
287 void insertEnumField(MemberDef *md) override;
288 void setEnumScope(MemberDef *md,bool livesInsideEnum=FALSE) override;
289 void setEnumClassScope(ClassDef *cd) override;
290 void setDocumentedEnumValues(bool value) override;
291 void setAnonymousEnumType(const MemberDef *md) override;
292 bool addExample(const QCString &anchor,const QCString &name,const QCString &file) override;
293 void setPrototype(bool p,const QCString &df,int line, int column) override;
294 void setExplicitExternal(bool b,const QCString &df,int line,int column) override;
295 void setDeclFile(const QCString &df,int line,int column) override;
296 void moveArgumentList(std::unique_ptr<ArgumentList> al) override;
297 void moveDeclArgumentList(std::unique_ptr<ArgumentList> al) override;
298 void setDefinitionTemplateParameterLists(const ArgumentLists &lists) override;
299 void setTypeConstraints(const ArgumentList &al) override;
300 void setType(const QCString &t) override;
301 void setAccessorType(ClassDef *cd,const QCString &t) override;
302 void setNamespace(NamespaceDef *nd) override;
303 void setMemberGroup(MemberGroup *grp) override;
304 void setMemberGroupId(int id) override;
305 void makeImplementationDetail() override;
306 void setFromAnonymousScope(bool b) override;
307 void setFromAnonymousMember(MemberDef *m) override;
308 void overrideCallGraph(bool e) override;
309 void overrideCallerGraph(bool e) override;
310 void overrideReferencedByRelation(bool e) override;
311 void overrideReferencesRelation(bool e) override;
312 void overrideEnumValues(bool e) override;
313 void overrideInlineSource(bool e) override;
314 void setTemplateMaster(const MemberDef *mt) override;
315 void setFormalTemplateArguments(const ArgumentList &al) override;
316 void addListReference(const Definition *) override;
317 void addRequirementReferences(const Definition *) override;
318 void setDocsForDefinition(bool b) override;
319 void setGroupAlias(const MemberDef *md) override;
320 void cacheTypedefVal(const ClassDef *val,const QCString &templSpec,const QCString &resolvedType) override;
321 void invalidateTypedefValCache() override;
322 void invalidateCachedArgumentTypes() override;
323 void setMemberDefinition(MemberDef *md) override;
324 void setMemberDeclaration(MemberDef *md) override;
325 void copyArgumentNames(const MemberDef *bmd) override;
326 void setCategory(ClassDef *) override;
327 void setCategoryRelation(const MemberDef *) override;
328 void setDocumentation(const QCString &d,const QCString &docFile,int docLine,bool stripWhiteSpace=TRUE) override;
329 void setBriefDescription(const QCString &b,const QCString &briefFile,int briefLine) override;
330 void setInbodyDocumentation(const QCString &d,const QCString &inbodyFile,int inbodyLine) override;
331 void setHidden(bool b) override;
332 void setDocTransferDone() override;
333 void setRequiresClause(const QCString &req) override;
334 void incrementFlowKeyWordCount() override;
335 void writeDeclaration(OutputList &ol,
336 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
337 bool inGroup, int indentLevel,const ClassDef *inheritFrom=nullptr,const QCString &inheritId=QCString()) const override;
338 void writeDocumentation(const MemberList *ml,int memCount,int memTotal,OutputList &ol,
339 const QCString &scopeName,const Definition *container,
340 bool inGroup,bool showEnumValues=FALSE,bool
341 showInline=FALSE) const override;
342 void writeMemberDocSimple(OutputList &ol,const Definition *container) const override;
343 void writeEnumDeclaration(OutputList &typeDecl,
344 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const override;
345 void writeTagFile(TextStream &,bool useQualifiedName,bool showNamespaceMembers) const override;
346 void warnIfUndocumented() const override;
347 void warnIfUndocumentedParams() const override;
348 bool visibleInIndex() const override;
349 void detectUndocumentedParams(bool hasParamCommand,bool hasReturnCommand) const override;
350 std::unique_ptr<MemberDef> createTemplateInstanceMember(const ArgumentList &formalArgs,
351 const std::unique_ptr<ArgumentList> &actualArgs) const override;
352 void findSectionsInDocumentation() override;
353 void writeLink(OutputList &ol,
354 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
355 bool onlyText=FALSE) const override;
356 void resolveUnnamedParameters(const MemberDef *md) override;
357 void addQualifiers(const StringVector &qualifiers) override;
358 StringVector getQualifiers() const override;
359 ClassDefMutable *getClassDefMutable() override;
360 void setModuleDef(ModuleDef *mod) override;
361 int redefineCount() const override;
362 void setRedefineCount(int) override;
363
364 private:
365 void _computeLinkableInProject();
366 void _computeIsConstructor();
367 void _computeIsDestructor();
368 void _writeGroupInclude(OutputList &ol,bool inGroup) const;
369 void _writeMultiLineInitializer(OutputList &ol,const QCString &scopeName) const;
370 void _writeCallGraph(OutputList &ol) const;
371 void _writeCallerGraph(OutputList &ol) const;
372 void _writeReimplements(OutputList &ol) const;
373 bool _isReimplements() const;
374 void _writeReimplementedBy(OutputList &ol) const;
375 size_t _countReimplementedBy() const;
376 void _writeExamples(OutputList &ol) const;
377 void _writeTypeConstraints(OutputList &ol) const;
378 void _writeEnumValues(OutputList &ol,const Definition *container,
379 const QCString &cfname,const QCString &ciname,
380 const QCString &cname) const;
381 void _writeCategoryRelation(OutputList &ol) const;
382 void _writeTagData(const DefType) const;
383 void _writeTemplatePrefix(OutputList &ol, const Definition *def,
384 const ArgumentList &al, bool writeReqClause=true) const;
385 bool _hasVisibleCallGraph() const;
386 bool _hasVisibleCallerGraph() const;
387 bool _isAnonymousBitField() const;
388
389
390 void init(Definition *def,const QCString &t,const QCString &a,const QCString &e,
391 Protection p,Specifier v,bool s,Relationship r,
392 MemberType mt,const ArgumentList &tal,
393 const ArgumentList &al,const QCString &meta
394 );
395
396 uint8_t m_isLinkableCached; // 0 = not cached, 1=FALSE, 2=TRUE
397 uint8_t m_isConstructorCached; // 0 = not cached, 1=FALSE, 2=TRUE
398 uint8_t m_isDestructorCached; // 1 = not cached, 1=FALSE, 2=TRUE
399
400 ClassDef *m_classDef = nullptr; // member of or related to
401 FileDef *m_fileDef = nullptr; // member of file definition
402 NamespaceDef *m_nspace = nullptr; // the namespace this member is in.
403 ModuleDef *m_moduleDef = nullptr;
404
405 const MemberDef *m_enumScope = nullptr; // the enclosing scope, if this is an enum field
406 bool m_livesInsideEnum = false;
407 const MemberDef *m_annEnumType = nullptr; // the anonymous enum that is the type of this member
408 MemberVector m_enumFields; // enumeration fields
409
410 MemberDef *m_redefines = nullptr; // the members that this member redefines
411 MemberVector m_redefinedBy; // the list of members that redefine this one
412
413 MemberDef *m_memDef = nullptr; // member definition for this declaration
414 MemberDef *m_memDec = nullptr; // member declaration for this definition
415 ClassDef *m_relatedAlso = nullptr; // points to class marked by relatedAlso
416
417 ExampleList m_examples; // a dictionary of all examples for quick access
418
419 QCString m_type; // return actual type
420 QCString m_accessorType; // return type that tell how to get to this member
421 ClassDef *m_accessorClass = nullptr; // class that this member accesses (for anonymous types)
422 QCString m_args; // function arguments/variable array specifiers
423 QCString m_def; // member definition in code (fully qualified name)
424 QCString m_anc; // HTML anchor name
425 Specifier m_virt = Specifier::Normal; // normal/virtual/pure virtual
426 Protection m_prot = Protection::Public; // protection type [Public/Protected/Private]
427 QCString m_decl; // member declaration in class
428
429 QCString m_bitfields; // struct member bitfields
430 QCString m_read; // property read accessor
431 QCString m_write; // property write accessor
432 QCString m_exception; // exceptions that can be thrown
433 QCString m_initializer; // initializer
434 QCString m_extraTypeChars; // extra type info found after the argument list
435 QCString m_enumBaseType; // base type of the enum (C++11)
436 QCString m_requiresClause; // requires clause (C++20)
437 int m_initLines = 0; // number of lines in the initializer
438 bool m_docTransferDone = false;
439
440 TypeSpecifier m_memSpec; // The specifiers present for this member
441 VhdlSpecifier m_vhdlSpec;
442 MemberType m_mtype = MemberType::Define; // returns the kind of member
443 int m_maxInitLines = 0; // when the initializer will be displayed
444 int m_userInitLines = 0; // result of explicit \hideinitializer or \showinitializer
445 MemberDef *m_annMemb = nullptr;
446
447 ArgumentList m_defArgList; // argument list of this member definition
448 ArgumentList m_declArgList; // argument list of this member declaration
449
450 ArgumentList m_tArgList; // template argument list of function template
451 ArgumentList m_typeConstraints; // type constraints for template parameters
452 const MemberDef *m_templateMaster = nullptr;
453 std::optional<ArgumentList> m_formalTemplateArguments;
454 ArgumentLists m_defTmpArgLists; // lists of template argument lists
455 // (for template functions in nested template classes)
456
457 QCString m_metaData; // Slice metadata.
458
459 mutable ClassDef *m_cachedAnonymousType = nullptr; // if the member has an anonymous compound
460 // as its type then this is computed by
461 // getClassDefOfAnonymousType() and
462 // cached here.
463 std::map<const Definition *,const MemberList *> m_sectionMap;
464
465 const MemberDef *m_groupAlias = nullptr; // Member containing the definition
466 int m_grpId = 0; // group id
467 MemberGroup *m_memberGroup = nullptr; // group's member definition
468 GroupDef *m_group = nullptr; // group in which this member is in
469 Grouping::GroupPri_t m_grouppri = Grouping::GROUPING_AUTO_DEF; // priority of this definition
470 QCString m_groupFileName; // file where this grouping was defined
471 int m_groupStartLine = 0; // line " " " " "
472 MemberDef *m_groupMember = nullptr;
473
474 bool m_isTypedefValCached = false;
475 const ClassDef *m_cachedTypedefValue = nullptr;
476 QCString m_cachedTypedefTemplSpec;
477 QCString m_cachedResolvedType;
478
479 // documentation inheritance
480 const MemberDef *m_docProvider = nullptr;
481
482 // to store the output file base from tag files
483 QCString m_explicitOutputFileBase;
484
485 // to store extra qualifiers
486 StringVector m_qualifiers;
487
488 // objective-c
489 bool m_implOnly = false; // function found in implementation but not
490 // in the interface
491 mutable bool m_hasDocumentedParams = false; // guard to show only the first warning, acts as cache
492 mutable bool m_hasDocumentedReturnType = false; // guard to show only the first warning, acts as cache
493 bool m_isDMember = false;
494 Relationship m_related = Relationship::Member; // relationship of this to the class
495 bool m_stat = false; // is it a static function?
496 bool m_proto = false; // is it a prototype?
497 bool m_docEnumValues = false; // is an enum with documented enum values.
498
499 bool m_annScope = false; // member is part of an anonymous scope
500 mutable bool m_hasDetailedDescriptionCached = false;
501 mutable bool m_detailedDescriptionCachedValue = false;
502 // const member.
503 bool m_hasCallGraph = false;
504 bool m_hasCallerGraph = false;
505 bool m_hasReferencedByRelation = false;
506 bool m_hasReferencesRelation = false;
507 bool m_hasInlineSource = false;
508 bool m_hasEnumValues = false;
509 bool m_explExt = false; // member was explicitly declared external
510 bool m_tspec = false; // member is a template specialization
511 bool m_groupHasDocs = false; // true if the entry that caused the grouping was documented
512 bool m_docsForDefinition = false; // TRUE => documentation block is put before
513 // definition.
514 // FALSE => block is put before declaration.
515 ClassDef *m_category = nullptr;
516 const MemberDef *m_categoryRelation = nullptr;
517 QCString m_declFileName;
518 int m_declLine = -1;
519 int m_declColumn = -1;
520 int m_numberOfFlowKW = 0;
521 int m_redefineCount = 0;
522};
523
524std::unique_ptr<MemberDef> createMemberDef(const QCString &defFileName,int defLine,int defColumn,
525 const QCString &type,const QCString &name,const QCString &args,
526 const QCString &excp,Protection prot,Specifier virt,bool stat,
527 Relationship related,MemberType t,const ArgumentList &tal,
528 const ArgumentList &al,const QCString &metaData)
529{
530 return std::make_unique<MemberDefImpl>(defFileName,defLine,defColumn,type,name,args,excp,prot,virt,
531 stat,related,t,tal,al,metaData);
532}
533
534//-----------------------------------------------------------------------------
535
536class MemberDefAliasImpl final : public DefinitionAliasMixin<MemberDef>
537{
538 public:
539 MemberDefAliasImpl(const Definition *newScope,const MemberDef *md)
540 : DefinitionAliasMixin(newScope,md), m_memberGroup(nullptr) { init(); }
541 ~MemberDefAliasImpl() override { deinit(); }
542 NON_COPYABLE(MemberDefAliasImpl)
543
544 DefType definitionType() const override { return TypeMember; }
545
546 const MemberDef *getMdAlias() const { return toMemberDef(getAlias()); }
547 MemberDef *getMdAlias() { return toMemberDef(const_cast<Definition*>(getAlias())); }
548 MemberDef *resolveAlias() override { return const_cast<MemberDef*>(getMdAlias()); }
549 const MemberDef *resolveAlias() const override { return getMdAlias(); }
550
551 std::unique_ptr<MemberDef> deepCopy() const override {
552 return createMemberDefAlias(getScope(),getMdAlias());
553 }
554 void moveTo(Definition *) override {}
555
556 const QCString &name() const override
557 { return getMdAlias()->name(); }
558 CodeSymbolType codeSymbolType() const override
559 { return getMdAlias()->codeSymbolType(); }
560 QCString getOutputFileBase() const override
561 { return getMdAlias()->getOutputFileBase(); }
562 QCString getReference() const override
563 { return getMdAlias()->getReference(); }
564 QCString anchor() const override
565 { return getMdAlias()->anchor(); }
566 QCString declaration() const override
567 { return getMdAlias()->declaration(); }
568 QCString definition() const override
569 { return getMdAlias()->definition(); }
570 QCString typeString() const override
571 { return getMdAlias()->typeString(); }
572 QCString argsString() const override
573 { return getMdAlias()->argsString(); }
574 QCString excpString() const override
575 { return getMdAlias()->excpString(); }
576 QCString bitfieldString() const override
577 { return getMdAlias()->bitfieldString(); }
578 QCString extraTypeChars() const override
579 { return getMdAlias()->extraTypeChars(); }
580 const QCString &initializer() const override
581 { return getMdAlias()->initializer(); }
582 int initializerLines() const override
583 { return getMdAlias()->initializerLines(); }
586 VhdlSpecifier getVhdlSpecifiers() const override
587 { return getMdAlias()->getVhdlSpecifiers(); }
588 const MemberList *getSectionList(const Definition *container) const override
589 { return getMdAlias()->getSectionList(container); }
590 QCString displayDefinition() const override
591 { return getMdAlias()->displayDefinition(); }
592
593 const ClassDef *getClassDef() const override
594 { return getMdAlias()->getClassDef(); }
595 ClassDef *getClassDef() override
596 { return getMdAlias()->getClassDef(); }
597
598 const FileDef *getFileDef() const override
599 { return getMdAlias()->getFileDef(); }
600 FileDef *getFileDef() override
601 { return getMdAlias()->getFileDef(); }
602
603 const ModuleDef *getModuleDef() const override
604 { return getMdAlias()->getModuleDef(); }
605
606 const NamespaceDef* getNamespaceDef() const override
607 { return getMdAlias()->getNamespaceDef(); }
608 NamespaceDef* getNamespaceDef() override
609 { return getMdAlias()->getNamespaceDef(); }
610
611 const ClassDef *accessorClass() const override
612 { return getMdAlias()->accessorClass(); }
613 QCString getReadAccessor() const override
614 { return getMdAlias()->getReadAccessor(); }
615 QCString getWriteAccessor() const override
616 { return getMdAlias()->getWriteAccessor(); }
617 const GroupDef *getGroupDef() const override
618 { return getMdAlias()->getGroupDef(); }
619 GroupDef *getGroupDef() override
620 { return getMdAlias()->getGroupDef(); }
621 Grouping::GroupPri_t getGroupPri() const override
622 { return getMdAlias()->getGroupPri(); }
623 QCString getGroupFileName() const override
624 { return getMdAlias()->getGroupFileName(); }
625 int getGroupStartLine() const override
626 { return getMdAlias()->getGroupStartLine(); }
627 bool getGroupHasDocs() const override
628 { return getMdAlias()->getGroupHasDocs(); }
629 QCString qualifiedName() const override
630 { return getMdAlias()->qualifiedName(); }
631 QCString objCMethodName(bool localLink,bool showStatic) const override
632 { return getMdAlias()->objCMethodName(localLink,showStatic); }
633 Protection protection() const override
634 { return getMdAlias()->protection(); }
635 Specifier virtualness(int /* count */) const override
636 { return getMdAlias()->virtualness(); }
637 MemberType memberType() const override
638 { return getMdAlias()->memberType(); }
639 QCString memberTypeName() const override
640 { return getMdAlias()->memberTypeName(); }
641 bool isSignal() const override
642 { return getMdAlias()->isSignal(); }
643 bool isSlot() const override
644 { return getMdAlias()->isSlot(); }
645 bool isVariable() const override
646 { return getMdAlias()->isVariable(); }
647 bool isEnumerate() const override
648 { return getMdAlias()->isEnumerate(); }
649 bool isEnumValue() const override
650 { return getMdAlias()->isEnumValue(); }
651 bool isTypedef() const override
652 { return getMdAlias()->isTypedef(); }
653 bool isSequence() const override
654 { return getMdAlias()->isSequence(); }
655 bool isDictionary() const override
656 { return getMdAlias()->isDictionary(); }
657 bool isFunction() const override
658 { return getMdAlias()->isFunction(); }
659 bool isFunctionPtr() const override
660 { return getMdAlias()->isFunctionPtr(); }
661 bool isDefine() const override
662 { return getMdAlias()->isDefine(); }
663 bool isFriend() const override
664 { return getMdAlias()->isFriend(); }
665 bool isDCOP() const override
666 { return getMdAlias()->isDCOP(); }
667 bool isProperty() const override
668 { return getMdAlias()->isProperty(); }
669 bool isEvent() const override
670 { return getMdAlias()->isEvent(); }
671 bool isRelated() const override
672 { return getMdAlias()->isRelated(); }
673 bool isForeign() const override
674 { return getMdAlias()->isForeign(); }
675 bool isStatic() const override
676 { return getMdAlias()->isStatic(); }
677 bool isInline() const override
678 { return getMdAlias()->isInline(); }
679 bool isExplicit() const override
680 { return getMdAlias()->isExplicit(); }
681 bool isMutable() const override
682 { return getMdAlias()->isMutable(); }
683 bool isThreadLocal() const override
684 { return getMdAlias()->isThreadLocal(); }
685 bool isGettable() const override
686 { return getMdAlias()->isGettable(); }
687 bool isPrivateGettable() const override
688 { return getMdAlias()->isPrivateGettable(); }
689 bool isProtectedGettable() const override
690 { return getMdAlias()->isProtectedGettable(); }
691 bool isSettable() const override
692 { return getMdAlias()->isSettable(); }
693 bool isPrivateSettable() const override
694 { return getMdAlias()->isPrivateSettable(); }
695 bool isProtectedSettable() const override
696 { return getMdAlias()->isProtectedSettable(); }
697 bool isReadable() const override
698 { return getMdAlias()->isReadable(); }
699 bool isWritable() const override
700 { return getMdAlias()->isWritable(); }
701 bool isAddable() const override
702 { return getMdAlias()->isAddable(); }
703 bool isRemovable() const override
704 { return getMdAlias()->isRemovable(); }
705 bool isRaisable() const override
706 { return getMdAlias()->isRaisable(); }
707 bool isFinal() const override
708 { return getMdAlias()->isFinal(); }
709 bool isAbstract() const override
710 { return getMdAlias()->isAbstract(); }
711 bool isOverride() const override
712 { return getMdAlias()->isOverride(); }
713 bool isInitonly() const override
714 { return getMdAlias()->isInitonly(); }
715 bool isOptional() const override
716 { return getMdAlias()->isOptional(); }
717 bool isRequired() const override
718 { return getMdAlias()->isRequired(); }
719 bool isNonAtomic() const override
720 { return getMdAlias()->isNonAtomic(); }
721 bool isCopy() const override
722 { return getMdAlias()->isCopy(); }
723 bool isAssign() const override
724 { return getMdAlias()->isAssign(); }
725 bool isRetain() const override
726 { return getMdAlias()->isRetain(); }
727 bool isWeak() const override
728 { return getMdAlias()->isWeak(); }
729 bool isStrong() const override
730 { return getMdAlias()->isStrong(); }
731 bool isEnumStruct() const override
732 { return getMdAlias()->isEnumStruct(); }
733 bool isUnretained() const override
734 { return getMdAlias()->isUnretained(); }
735 bool isNew() const override
736 { return getMdAlias()->isNew(); }
737 bool isSealed() const override
738 { return getMdAlias()->isSealed(); }
739 bool isImplementation() const override
740 { return getMdAlias()->isImplementation(); }
741 bool isExternal() const override
742 { return getMdAlias()->isExternal(); }
743 bool isTypeAlias() const override
744 { return getMdAlias()->isTypeAlias(); }
745 bool isDefault() const override
746 { return getMdAlias()->isDefault(); }
747 bool isDelete() const override
748 { return getMdAlias()->isDelete(); }
749 bool isNoExcept() const override
750 { return getMdAlias()->isNoExcept(); }
751 bool isAttribute() const override
752 { return getMdAlias()->isAttribute(); }
753 bool isUNOProperty() const override
754 { return getMdAlias()->isUNOProperty(); }
755 bool isReadonly() const override
756 { return getMdAlias()->isReadable(); }
757 bool isBound() const override
758 { return getMdAlias()->isBound(); }
759 bool isConstrained() const override
760 { return getMdAlias()->isConstrained(); }
761 bool isTransient() const override
762 { return getMdAlias()->isTransient(); }
763 bool isMaybeVoid() const override
764 { return getMdAlias()->isMaybeVoid(); }
765 bool isMaybeDefault() const override
766 { return getMdAlias()->isMaybeDefault(); }
767 bool isMaybeAmbiguous() const override
768 { return getMdAlias()->isMaybeAmbiguous(); }
769 bool isPublished() const override
770 { return getMdAlias()->isPublished(); }
771 bool isTemplateSpecialization() const override
772 { return getMdAlias()->isTemplateSpecialization(); }
773 bool isObjCMethod() const override
774 { return getMdAlias()->isObjCMethod(); }
775 bool isObjCProperty() const override
776 { return getMdAlias()->isObjCProperty(); }
777 bool isCSharpProperty() const override
778 { return getMdAlias()->isCSharpProperty(); }
779 bool isConstructor() const override
780 { return getMdAlias()->isConstructor(); }
781 bool isDestructor() const override
782 { return getMdAlias()->isDestructor(); }
783 bool hasOneLineInitializer() const override
784 { return getMdAlias()->hasOneLineInitializer(); }
785 bool hasMultiLineInitializer() const override
786 { return getMdAlias()->hasMultiLineInitializer(); }
787 bool isCallable() const override
788 { return getMdAlias()->isCallable(); }
789 bool isStrongEnumValue() const override
790 { return getMdAlias()->isStrongEnumValue(); }
791 bool livesInsideEnum() const override
792 { return getMdAlias()->livesInsideEnum(); }
793 bool isSliceLocal() const override
794 { return getMdAlias()->isSliceLocal(); }
795 bool isNoDiscard() const override
796 { return getMdAlias()->isNoDiscard(); }
797 bool isConstExpr() const override
798 { return getMdAlias()->isConstExpr(); }
799 bool isConstEval() const override
800 { return getMdAlias()->isConstEval(); }
801 bool isConstInit() const override
802 { return getMdAlias()->isConstInit(); }
803 int numberOfFlowKeyWords() const override
804 { return getMdAlias()->numberOfFlowKeyWords(); }
805 bool isFriendToHide() const override
806 { return getMdAlias()->isFriendToHide(); }
807 bool isNotFriend() const override
808 { return getMdAlias()->isNotFriend(); }
809 bool isFunctionOrSignalSlot() const override
810 { return getMdAlias()->isFunctionOrSignalSlot(); }
811 bool isRelatedOrFriend() const override
812 { return getMdAlias()->isRelatedOrFriend(); }
813 bool isLinkableInProject() const override
814 { return getMdAlias()->isLinkableInProject(); }
815 bool isLinkable() const override
816 { return getMdAlias()->isLinkable(); }
817 bool hasDocumentation() const override
818 { return getMdAlias()->hasDocumentation(); }
819 bool hasUserDocumentation() const override
820 { return getMdAlias()->hasUserDocumentation(); }
821 bool isDeleted() const override
822 { return getMdAlias()->isDeleted(); }
823 bool isBriefSectionVisible() const override
824 { return getMdAlias()->isBriefSectionVisible(); }
825 bool isDetailedSectionVisible(MemberListContainer container) const override
826 { return getMdAlias()->isDetailedSectionVisible(container); }
827 bool hasDetailedDescription() const override
828 { return getMdAlias()->hasDetailedDescription(); }
829 bool isFriendClass() const override
830 { return getMdAlias()->isFriendClass(); }
831 bool isDocumentedFriendClass() const override
832 { return getMdAlias()->isDocumentedFriendClass(); }
833 const MemberDef *reimplements() const override
834 { return getMdAlias()->reimplements(); }
835 const MemberVector &reimplementedBy() const override
836 { return getMdAlias()->reimplementedBy(); }
837 bool isReimplementedBy(const ClassDef *cd) const override
838 { return getMdAlias()->isReimplementedBy(cd); }
839 ClassDef *relatedAlso() const override
840 { return getMdAlias()->relatedAlso(); }
841 bool hasDocumentedEnumValues() const override
842 { return getMdAlias()->hasDocumentedEnumValues(); }
843 const MemberDef *getAnonymousEnumType() const override
844 { return getMdAlias()->getAnonymousEnumType(); }
845 bool isDocsForDefinition() const override
846 { return getMdAlias()->isDocsForDefinition(); }
847 const MemberDef *getEnumScope() const override
848 { return getMdAlias()->getEnumScope(); }
849 const MemberVector &enumFieldList() const override
850 { return getMdAlias()->enumFieldList(); }
851 QCString enumBaseType() const override
852 { return getMdAlias()->enumBaseType(); }
853 bool hasExamples() const override
854 { return getMdAlias()->hasExamples(); }
855 const ExampleList &getExamples() const override
856 { return getMdAlias()->getExamples(); }
857 bool isPrototype() const override
858 { return getMdAlias()->isPrototype(); }
859 const ArgumentList &argumentList() const override
860 { return getMdAlias()->argumentList(); }
861 const ArgumentList &declArgumentList() const override
862 { return getMdAlias()->declArgumentList(); }
863 const ArgumentList &templateArguments() const override
864 { return getMdAlias()->templateArguments(); }
867 std::optional<ArgumentList> formalTemplateArguments() const override
868 { return getMdAlias()->formalTemplateArguments(); }
869 int getMemberGroupId() const override
870 { return getMdAlias()->getMemberGroupId(); }
871 MemberGroup *getMemberGroup() const override
872 { return m_memberGroup; }
873 bool fromAnonymousScope() const override
874 { return getMdAlias()->fromAnonymousScope(); }
875 MemberDef *fromAnonymousMember() const override
876 { return getMdAlias()->fromAnonymousMember(); }
877 bool hasCallGraph() const override
878 { return getMdAlias()->hasCallGraph(); }
879 bool hasCallerGraph() const override
880 { return getMdAlias()->hasCallerGraph(); }
881 bool hasReferencesRelation() const override
882 { return getMdAlias()->hasReferencesRelation(); }
883 bool hasReferencedByRelation() const override
884 { return getMdAlias()->hasReferencedByRelation(); }
885 bool hasInlineSource() const override
886 { return getMdAlias()->hasInlineSource(); }
887 bool isDocTransferDone() const override
888 { return getMdAlias()->isDocTransferDone(); }
889 QCString sourceRefName() const override
890 { return getMdAlias()->sourceRefName(); }
891 bool hasEnumValues() const override
892 { return getMdAlias()->hasEnumValues(); }
893 StringVector getQualifiers() const override
894 { return getMdAlias()->getQualifiers(); }
895 const MemberDef *templateMaster() const override
896 { return getMdAlias()->templateMaster(); }
897 QCString getScopeString() const override
898 { return getMdAlias()->getScopeString(); }
901 bool isTypedefValCached() const override
902 { return getMdAlias()->isTypedefValCached(); }
903 const ClassDef *getCachedTypedefVal() const override
904 { return getMdAlias()->getCachedTypedefVal(); }
909 MemberDef *memberDefinition() const override
910 { return getMdAlias()->memberDefinition(); }
911 MemberDef *memberDeclaration() const override
912 { return getMdAlias()->memberDeclaration(); }
913 const MemberDef *inheritsDocsFrom() const override
914 { return getMdAlias()->inheritsDocsFrom(); }
915 const MemberDef *getGroupAlias() const override
916 { return getMdAlias()->getGroupAlias(); }
917 ClassDef *category() const override
918 { return getMdAlias()->category(); }
919 const MemberDef *categoryRelation() const override
920 { return getMdAlias()->categoryRelation(); }
921 QCString displayName(bool b=TRUE) const override
922 { return getMdAlias()->displayName(b); }
923 QCString getDeclType() const override
924 { return getMdAlias()->getDeclType(); }
925 StringVector getLabels(const Definition *container) const override
926 { return getMdAlias()->getLabels(container); }
927 const ArgumentList &typeConstraints() const override
928 { return getMdAlias()->typeConstraints(); }
929 QCString documentation() const override
930 { return getMdAlias()->documentation(); }
931 QCString briefDescription(bool /* abbr=FALSE */) const override
932 { return getMdAlias()->briefDescription(); }
933 QCString fieldType() const override
934 { return getMdAlias()->fieldType(); }
935 bool isReference() const override
936 { return getMdAlias()->isReference(); }
937 QCString getDeclFileName() const override
938 { return getMdAlias()->getDeclFileName(); }
939 int getDeclLine() const override
940 { return getMdAlias()->getDeclLine(); }
941 int getDeclColumn() const override
942 { return getMdAlias()->getDeclColumn(); }
943 QCString requiresClause() const override
944 { return getMdAlias()->requiresClause(); }
945 bool visibleInIndex() const override
946 { return getMdAlias()->visibleInIndex(); }
947 int redefineCount() const override
948 { return getMdAlias()->redefineCount(); }
949
950 void warnIfUndocumented() const override {}
951 void warnIfUndocumentedParams() const override {}
952 void detectUndocumentedParams(bool /* hasParamCommand */,bool /* hasReturnCommand */) const override {}
953 void setMemberGroup(MemberGroup *grp) override { m_memberGroup = grp; }
954 std::unique_ptr<MemberDef> createTemplateInstanceMember(const ArgumentList &formalArgs,
955 const std::unique_ptr<ArgumentList> &actualArgs) const override
956 { return getMdAlias()->createTemplateInstanceMember(formalArgs,actualArgs); }
957
958 void writeDeclaration(OutputList &ol,
959 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
960 bool inGroup, int indentLevel, const ClassDef *inheritFrom=nullptr,const QCString &inheritId=QCString()) const override
961 {
962 getMdAlias()->writeDeclaration(ol,cd,nd,fd,gd,mod,inGroup,indentLevel,inheritFrom,inheritId);
963 }
964 void writeEnumDeclaration(OutputList &typeDecl,
965 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const override
966 {
967 getMdAlias()->writeEnumDeclaration(typeDecl,cd,nd,fd,gd,mod);
968 }
969 void writeLink(OutputList &ol,
970 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
971 bool onlyText=FALSE) const override
972 {
973 getMdAlias()->writeLink(ol,cd,nd,fd,gd,mod,onlyText);
974 }
975 private:
976 MemberGroup *m_memberGroup; // group's member definition
977};
978
979
980std::unique_ptr<MemberDef> createMemberDefAlias(const Definition *newScope,const MemberDef *aliasMd)
981{
982 auto amd = std::make_unique<MemberDefAliasImpl>(newScope,aliasMd);
983 //printf("amd: name=%s displayName=%s\n",qPrint(amd->name()),qPrint(amd->displayName()));
984 return amd;
985}
986
987//-----------------------------------------------------------------------------
988
989static QCString addTemplateNames(const QCString &s,const QCString &n,const QCString &t)
990{
991 QCString result;
992 QCString clRealName=n;
993 int p=0,i=0;
994 if ((i=clRealName.find('<'))!=-1)
995 {
996 clRealName=clRealName.left(i); // strip template specialization
997 }
998 if ((i=clRealName.findRev("::"))!=-1)
999 {
1000 clRealName=clRealName.right(clRealName.length()-i-2);
1001 }
1002 while ((i=s.find(clRealName,p))!=-1)
1003 {
1004 result+=s.mid(p,i-p);
1005 size_t j=clRealName.length()+i;
1006 if (s.length()==j || (s.at(j)!='<' && !isId(s.at(j))))
1007 { // add template names
1008 //printf("Adding %s+%s\n",qPrint(clRealName),qPrint(t));
1009 result+=clRealName+t;
1010 }
1011 else
1012 { // template names already present
1013 //printf("Adding %s\n",qPrint(clRealName));
1014 result+=clRealName;
1015 }
1016 p=i+static_cast<int>(clRealName.length());
1017 }
1018 result+=s.right(s.length()-p);
1019 //printf("addTemplateNames(%s,%s,%s)=%s\n",qPrint(s),qPrint(n),qPrint(t),qPrint(result));
1020 return result;
1021}
1022
1023// ol.startMemberDocName has already been done before this is called.
1024// when this function returns TRUE, ol.endParameterList will be called.
1025//
1026// typical sequence:
1027// ol.startMemberDoc
1028// ol.startMemberDocName
1029// --- enter writeDefArgumentList
1030// ol.endMemberDocName
1031// ol.startParameterList
1032// ...
1033// ol.startParameterType(first=TRUE)
1034// ol.endParameterType
1035// ol.startParameterName
1036// ol.endParameterName
1037// ol.startParameterExtra
1038// ol.startParameterDefVal [optional]
1039// ol.endParameterDefVal [optional]
1040// ol.endParameterExtra(last==FALSE)
1041// ...
1042// ol.startParameterType(first=FALSE)
1043// ol.endParameterType
1044// ol.startParameterName
1045// ol.endParameterName
1046// ol.startParameterExtra
1047// ol.endParameterExtra(last==TRUE)
1048// ...
1049// --- leave writeDefArgumentList with return value TRUE
1050// ol.endParameterList
1051// ol.endMemberDoc(hasArgs=TRUE)
1052//
1053// For an empty list the function should return FALSE, the sequence is
1054// ol.startMemberDoc
1055// ol.startMemberDocName
1056// --- enter writeDefArgumentList
1057// --- leave writeDefArgumentList with return value FALSE
1058// ol.endMemberDocName
1059// ol.endMemberDoc(hasArgs=FALSE);
1060//
1061
1062static bool writeDefArgumentList(OutputList &ol,const Definition *scope,const MemberDef *md)
1063{
1064 const ArgumentList &defArgList=(md->isDocsForDefinition()) ?
1065 md->argumentList() : md->declArgumentList();
1066 //printf("writeDefArgumentList '%s' isDocsForDefinition()=%d hasParameters()=%d (%s)\n",
1067 // qPrint(md->name()),md->isDocsForDefinition(),defArgList.hasParameters(),qPrint(argListToString(defArgList)));
1068 if (!defArgList.hasParameters() || md->isProperty() || md->isTypedef())
1069 {
1070 return FALSE; // member has no function like argument list
1071 }
1072
1073 bool isDefine = md->isDefine();
1074 if (!isDefine) ol.docify(" ");
1075
1076 //printf("writeDefArgList(%d)\n",defArgList->count());
1077 ol.endMemberDocName();
1078 ol.startParameterList(!md->isObjCMethod());
1079 //printf("===> name=%s isDefine=%d\n",qPrint(md->name()),md->isDefine());
1080
1081 QCString cName;
1082 if (scope)
1083 {
1084 cName=scope->name();
1085 int il=cName.find('<');
1086 int ir=cName.findRev('>');
1087 if (il!=-1 && ir!=-1 && ir>il)
1088 {
1089 cName=cName.mid(il,ir-il+1);
1090 //printf("1. cName=%s\n",qPrint(cName));
1091 }
1092 else if (scope->definitionType()==Definition::TypeClass)
1093 {
1094 cName=tempArgListToString((toClassDef(scope))->templateArguments(),
1095 scope->getLanguage());
1096 //printf("2. cName=%s\n",qPrint(cName));
1097 }
1098 else // no template specifier
1099 {
1100 cName.clear();
1101 }
1102 }
1103 //printf("~~~ %s cName=%s\n",qPrint(md->name()),qPrint(cName));
1104
1105 QCString sep = getLanguageSpecificSeparator(md->getLanguage(),true);
1106
1107 LinkifyTextOptions options;
1108 options.setScope(scope).setFileScope(md->getBodyDef()).setSelf(md);
1109
1110 bool first=TRUE;
1111 bool paramTypeStarted=FALSE;
1112 auto alIt = defArgList.begin();
1113 while (alIt!=defArgList.end())
1114 {
1115 Argument a = *alIt;
1116 if (isDefine || first)
1117 {
1118 ol.startParameterType(first,QCString());
1119 paramTypeStarted=true;
1120 if (isDefine)
1121 {
1122 ol.endParameterType();
1123 ol.startParameterName(TRUE);
1124 }
1125 }
1126
1127 if (!a.attrib.isEmpty() && !md->isObjCMethod()) // argument has an IDL attribute
1128 {
1129 ol.docify(a.attrib+" ");
1130 }
1131
1132 QCString atype = a.type;
1133 if (sep!="::") { atype=substitute(atype,"::",sep); }
1134
1135 int funcPtrPos=-1;
1136 {
1137 if (md->isObjCMethod()) { atype.prepend("("); atype.append(")"); }
1138 if (atype!="...")
1139 {
1140 if (!cName.isEmpty() && scope && scope!=Doxygen::globalScope)
1141 {
1142 atype=addTemplateNames(atype,scope->name(),cName);
1143 }
1144 // 1. split ...*)(... -> '*' + name + ')(...'
1145 // 2. split ...*[some thing])(... -> '*' + name + '[some thing])(...'
1146 int starPos = atype.find('*'); // find pointer
1147 if (starPos==-1) starPos = atype.find('&'); // can also be reference
1148 funcPtrPos = atype.find(")(");
1149 if (starPos!=-1 && funcPtrPos>starPos)
1150 {
1151 funcPtrPos=starPos+1;
1152 }
1153 else
1154 {
1155 funcPtrPos=-1;
1156 }
1157 linkifyText(TextGeneratorOLImpl(ol),
1158 funcPtrPos==-1 ? atype : atype.left(funcPtrPos),
1159 options);
1160 }
1161 }
1162
1163 if (!isDefine)
1164 {
1165 if (paramTypeStarted)
1166 {
1167 ol.endParameterType();
1168 paramTypeStarted=FALSE;
1169 }
1170 ol.startParameterName(defArgList.size()<2);
1171 }
1172 else
1173 {
1174 ol.endParameterName();
1175 }
1176
1177 if (atype=="...")
1178 {
1179 ol.docify(atype);
1180 }
1181 else if (!a.name.isEmpty()) // argument has a name
1182 {
1183 ol.docify(a.name);
1184 }
1185 if (!isDefine)
1186 {
1187 if (funcPtrPos!=-1)
1188 {
1189 ol.writeNonBreakableSpace(1);
1190 }
1191 ol.endParameterName();
1192 }
1193 ol.startParameterExtra();
1194 if (funcPtrPos!=-1)
1195 {
1196 linkifyText(TextGeneratorOLImpl(ol),atype.mid(funcPtrPos),options);
1197 }
1198 if (!a.array.isEmpty())
1199 {
1200 ol.docify(a.array);
1201 }
1202 if (!a.defval.isEmpty()) // write the default value
1203 {
1204 QCString n=a.defval;
1205 if (scope && scope!=Doxygen::globalScope && !cName.isEmpty())
1206 {
1207 n=addTemplateNames(n,scope->name(),cName);
1208 }
1209 ol.startParameterDefVal(" = ");
1210 linkifyText(TextGeneratorOLImpl(ol),n,LinkifyTextOptions(options).setKeepSpaces(true));
1211 ol.endParameterDefVal();
1212 }
1213 ++alIt;
1214 if (alIt!=defArgList.end())
1215 {
1216 a = *alIt;
1217 if (!md->isObjCMethod()) ol.docify(", "); // there are more arguments
1218 if (!isDefine)
1219 {
1220 QCString key;
1221 if (md->isObjCMethod() && a.attrib.length()>=2)
1222 {
1223 //printf("Found parameter keyword %s\n",a.qPrint(attrib));
1224 // strip [ and ]
1225 key=a.attrib.mid(1,a.attrib.length()-2);
1226 if (key!=",") key+=":"; // for normal keywords add colon
1227 }
1228 ol.endParameterExtra(false,false,!md->isObjCMethod());
1229 ol.startParameterType(FALSE,key);
1230 paramTypeStarted=TRUE;
1231 }
1232 else // isDefine
1233 {
1234 ol.endParameterExtra(false,false,true);
1235 }
1236 }
1237 first=FALSE;
1238 }
1239 if (first)
1240 {
1241 ol.startParameterName(defArgList.size()<2);
1242 ol.endParameterName();
1243 ol.startParameterExtra();
1244 }
1245 ol.endParameterExtra(TRUE,defArgList.size()<2,!md->isObjCMethod());
1246 if (!md->extraTypeChars().isEmpty())
1247 {
1248 ol.docify(md->extraTypeChars());
1249 }
1250 if (defArgList.constSpecifier())
1251 {
1252 ol.docify(" const");
1253 }
1254 if (defArgList.volatileSpecifier())
1255 {
1256 ol.docify(" volatile");
1257 }
1258 if (defArgList.refQualifier()==RefQualifierType::LValue)
1259 {
1260 ol.docify(" &");
1261 }
1262 else if (defArgList.refQualifier()==RefQualifierType::RValue)
1263 {
1264 ol.docify(" &&");
1265 }
1266 if (!defArgList.trailingReturnType().isEmpty())
1267 {
1268 linkifyText(TextGeneratorOLImpl(ol), defArgList.trailingReturnType(), options);
1269 }
1270 return TRUE;
1271}
1272
1273static void writeExceptionListImpl(
1274 OutputList &ol, const ClassDef *cd, const MemberDef *md, QCString const& exception)
1275{
1276 // this is ordinary exception spec - there must be a '('
1277 //printf("exception='%s'\n",qPrint(exception));
1278 int index = exception.find('(');
1279 LinkifyTextOptions options;
1280 options.setScope(cd).setFileScope(md->getBodyDef()).setSelf(md);
1281 if (index!=-1)
1282 {
1283 ol.exceptionEntry(exception.left(index),false);
1284 ++index; // paren in second column so skip it here
1285 for (int comma = exception.find(',', index); comma!=-1; )
1286 {
1287 ++comma; // include comma
1288 linkifyText(TextGeneratorOLImpl(ol),exception.mid(index,comma-index),options);
1289 ol.exceptionEntry(QCString(),false);
1290 index=comma;
1291 comma = exception.find(',', index);
1292 }
1293 int close = exception.find(')', index);
1294 if (close!=-1)
1295 {
1296 QCString type=removeRedundantWhiteSpace(exception.mid(index,close-index));
1297 linkifyText(TextGeneratorOLImpl(ol),type,options);
1298 ol.exceptionEntry(QCString(),true);
1299 }
1300 else
1301 {
1302 warn(md->getDefFileName(),md->getDefLine(),
1303 "missing ) in exception list on member {}",md->name());
1304 }
1305 }
1306 else // Java Exception
1307 {
1308 ol.docify(" ");
1309 linkifyText(TextGeneratorOLImpl(ol),exception,options);
1310 }
1311}
1312
1313static void writeExceptionList(OutputList &ol, const ClassDef *cd, const MemberDef *md)
1314{
1315 QCString exception = md->excpString().stripWhiteSpace();
1316 if ('{'==exception.at(0))
1317 {
1318 // this is an UNO IDL attribute - need special handling
1319 int index = exception.find(';');
1320 int oldIndex = 1;
1321 while (-1 != index) // there should be no more than 2 (set / get)
1322 {
1323 // omit '{' and ';' -> "set raises (...)"
1324 writeExceptionListImpl(ol,cd,md,exception.mid(oldIndex,index-oldIndex));
1325 oldIndex=index+1;
1326 index = exception.find(';',oldIndex);
1327 }
1328 // the rest is now just '}' - omit that
1329 }
1330 else
1331 {
1332 writeExceptionListImpl(ol,cd,md,exception);
1333 }
1334}
1335
1336//-----------------------------------------------------------------------------
1337//-----------------------------------------------------------------------------
1338//-----------------------------------------------------------------------------
1339
1340void MemberDefImpl::init(Definition *d,
1341 const QCString &t,const QCString &a,const QCString &e,
1342 Protection p,Specifier v,bool s,Relationship r,
1343 MemberType mt,const ArgumentList &tal,
1344 const ArgumentList &al,const QCString &meta
1345 )
1346{
1347 m_classDef=nullptr;
1348 m_fileDef=nullptr;
1349 m_moduleDef=nullptr;
1350 m_redefines=nullptr;
1351 m_relatedAlso=nullptr;
1352 m_accessorClass=nullptr;
1353 m_nspace=nullptr;
1354 m_memDef=nullptr;
1355 m_memDec=nullptr;
1356 m_group=nullptr;
1357 m_grpId=-1;
1358 m_enumScope=nullptr;
1359 m_livesInsideEnum=FALSE;
1360 m_hasCallGraph = Config_getBool(CALL_GRAPH);
1361 m_hasCallerGraph = Config_getBool(CALLER_GRAPH);
1362 m_hasReferencedByRelation = Config_getBool(REFERENCED_BY_RELATION);
1363 m_hasReferencesRelation = Config_getBool(REFERENCES_RELATION);
1364 m_hasEnumValues = Config_getBool(SHOW_ENUM_VALUES);
1365 m_hasInlineSource = Config_getBool(INLINE_SOURCES);
1366 m_initLines=0;
1367 m_type=t;
1368 if (mt==MemberType::Typedef) m_type.stripPrefix("typedef ");
1369 // type.stripPrefix("struct ");
1370 // type.stripPrefix("class " );
1371 // type.stripPrefix("union " );
1372 m_type=removeRedundantWhiteSpace(m_type);
1373 m_args=a;
1374 m_args=removeRedundantWhiteSpace(m_args);
1375 if (m_type.isEmpty()) m_decl=d->name()+m_args; else m_decl=m_type+" "+d->name()+m_args;
1376
1377 m_memberGroup=nullptr;
1378 m_virt=v;
1379 m_prot=p;
1380 m_related=r;
1381 m_stat=s;
1382 m_mtype=mt;
1383 m_exception=e;
1384 m_proto=FALSE;
1385 m_annScope=FALSE;
1386 m_memSpec=TypeSpecifier();
1387 m_vhdlSpec=VhdlSpecifier::UNKNOWN;
1388 m_annMemb=nullptr;
1389 m_annEnumType=nullptr;
1390 m_groupAlias=nullptr;
1391 m_explExt=FALSE;
1392 m_tspec=FALSE;
1393 m_cachedAnonymousType=nullptr;
1394 m_maxInitLines=Config_getInt(MAX_INITIALIZER_LINES);
1395 m_userInitLines=-1;
1396 m_docEnumValues=FALSE;
1397 // copy function template arguments (if any)
1398 m_tArgList = tal;
1399 //printf("new member al=%p\n",al);
1400 // copy function definition arguments (if any)
1401 m_defArgList = al;
1402 // convert function declaration arguments (if any)
1403 if (!m_args.isEmpty())
1404 {
1405 m_declArgList = *stringToArgumentList(d->getLanguage(),m_args,&m_extraTypeChars);
1406 //printf("setDeclArgList %s to %s const=%d\n",qPrint(args),
1407 // qPrint(argListToString(declArgList)),declArgList->constSpecifier);
1408 }
1409 m_metaData = meta;
1410 m_templateMaster = nullptr;
1411 m_docsForDefinition = TRUE;
1412 m_isTypedefValCached = FALSE;
1413 m_cachedTypedefValue = nullptr;
1414 m_implOnly=FALSE;
1415 m_groupMember = nullptr;
1416 m_hasDocumentedParams = FALSE;
1417 m_hasDocumentedReturnType = FALSE;
1418 m_docProvider = nullptr;
1419 m_isDMember = d->getDefFileName().lower().endsWith(".d");
1420}
1421
1422
1423//-----------------------------------------------------------------------------
1424//-----------------------------------------------------------------------------
1425//-----------------------------------------------------------------------------
1426
1427/*! Creates a new member definition.
1428 *
1429 * \param df File containing the definition of this member.
1430 * \param dl Line at which the member definition was found.
1431 * \param dc Column at which the member definition was found.
1432 * \param t A string representing the type of the member.
1433 * \param na A string representing the name of the member.
1434 * \param a A string representing the arguments of the member.
1435 * \param e A string representing the throw clause of the members.
1436 * \param p The protection context of the member, possible values are:
1437 * \c Public, \c Protected, \c Private.
1438 * \param v The degree of 'virtualness' of the member, possible values are:
1439 * \c Normal, \c Virtual, \c Pure.
1440 * \param s A boolean that is true iff the member is static.
1441 * \param r The relationship between the class and the member.
1442 * \param mt The kind of member. See #MemberType for a list of
1443 * all types.
1444 * \param tal The template arguments of this member.
1445 * \param al The arguments of this member. This is a structured form of
1446 * the string past as argument \a a.
1447 * \param meta Slice metadata.
1448 */
1449
1450MemberDefImpl::MemberDefImpl(const QCString &df,int dl,int dc,
1451 const QCString &t,const QCString &na,const QCString &a,const QCString &e,
1452 Protection p,Specifier v,bool s,Relationship r,MemberType mt,
1453 const ArgumentList &tal,const ArgumentList &al,const QCString &meta
1454 ) : DefinitionMixin(df,dl,dc,removeRedundantWhiteSpace(na))
1455{
1456 //printf("MemberDefImpl::MemberDef(%s)\n",qPrint(na));
1457 init(this,t,a,e,p,v,s,r,mt,tal,al,meta);
1458 m_isLinkableCached = 0;
1459 m_isConstructorCached = 0;
1460 m_isDestructorCached = 0;
1461}
1462
1463std::unique_ptr<MemberDef> MemberDefImpl::deepCopy() const
1464{
1465 std::unique_ptr<MemberDefImpl> result(new MemberDefImpl(
1466 getDefFileName(),getDefLine(),getDefColumn(),m_type,localName(),m_args,m_exception,
1467 m_prot,m_virt,m_stat,m_related,m_mtype,m_tArgList,m_defArgList,m_metaData));
1468 // first copy base members
1469 result->DefinitionMixin<MemberDefMutable>::operator=(*this);
1470 // then copy other members
1471 result->m_typeConstraints = m_typeConstraints ;
1472 result->m_declArgList = m_declArgList ;
1473 result->m_classDef = m_classDef ;
1474 result->m_fileDef = m_fileDef ;
1475 result->m_moduleDef = m_moduleDef ;
1476 result->m_nspace = m_nspace ;
1477 result->m_enumScope = m_enumScope ;
1478 result->m_livesInsideEnum = m_livesInsideEnum ;
1479 result->m_annEnumType = m_annEnumType ;
1480 result->m_enumFields = m_enumFields ;
1481 result->m_redefines = m_redefines ;
1482 result->m_redefinedBy = m_redefinedBy ;
1483 result->m_memDef = m_memDef ;
1484 result->m_memDec = m_memDec ;
1485 result->m_relatedAlso = m_relatedAlso ;
1486 result->m_examples = m_examples ;
1487 result->m_accessorType = m_accessorType ;
1488 result->m_accessorClass = m_accessorClass ;
1489 result->m_def = m_def ;
1490 result->m_anc = m_anc ;
1491 result->m_decl = m_decl ;
1492 result->m_bitfields = m_bitfields ;
1493 result->m_read = m_read ;
1494 result->m_write = m_write ;
1495 result->m_exception = m_exception ;
1496 result->m_initializer = m_initializer ;
1497 result->m_extraTypeChars = m_extraTypeChars ;
1498 result->m_enumBaseType = m_enumBaseType ;
1499 result->m_requiresClause = m_requiresClause ;
1500 result->m_initLines = m_initLines ;
1501 result->m_memSpec = m_memSpec ;
1502 result->m_vhdlSpec = m_vhdlSpec ;
1503 result->m_maxInitLines = m_maxInitLines ;
1504 result->m_userInitLines = m_userInitLines ;
1505 result->m_annMemb = m_annMemb ;
1506 result->m_defArgList = m_defArgList ;
1507 result->m_declArgList = m_declArgList ;
1508 result->m_tArgList = m_tArgList ;
1509 result->m_typeConstraints = m_typeConstraints ;
1510 result->m_templateMaster = m_templateMaster ;
1511 result->m_formalTemplateArguments = m_formalTemplateArguments ;
1512 result->m_defTmpArgLists = m_defTmpArgLists ;
1513 result->m_cachedAnonymousType = m_cachedAnonymousType ;
1514 result->m_sectionMap = m_sectionMap ;
1515 result->m_groupAlias = m_groupAlias ;
1516 result->m_grpId = m_grpId ;
1517 result->m_memberGroup = m_memberGroup ;
1518 result->m_group = m_group ;
1519 result->m_grouppri = m_grouppri ;
1520 result->m_groupFileName = m_groupFileName ;
1521 result->m_groupStartLine = m_groupStartLine ;
1522 result->m_groupMember = m_groupMember ;
1523 result->m_isTypedefValCached = m_isTypedefValCached ;
1524 result->m_cachedTypedefValue = m_cachedTypedefValue ;
1525 result->m_cachedTypedefTemplSpec = m_cachedTypedefTemplSpec ;
1526 result->m_cachedResolvedType = m_cachedResolvedType ;
1527 result->m_docProvider = m_docProvider ;
1528 result->m_explicitOutputFileBase = m_explicitOutputFileBase ;
1529 result->m_qualifiers = m_qualifiers ;
1530 result->m_implOnly = m_implOnly ;
1531 result->m_hasDocumentedParams = m_hasDocumentedParams ;
1532 result->m_hasDocumentedReturnType = m_hasDocumentedReturnType ;
1533 result->m_isDMember = m_isDMember ;
1534 result->m_proto = m_proto ;
1535 result->m_docEnumValues = m_docEnumValues ;
1536 result->m_annScope = m_annScope ;
1537 result->m_hasDetailedDescriptionCached = m_hasDetailedDescriptionCached ;
1538 result->m_detailedDescriptionCachedValue = m_detailedDescriptionCachedValue ;
1539 result->m_hasCallGraph = m_hasCallGraph ;
1540 result->m_hasCallerGraph = m_hasCallerGraph ;
1541 result->m_hasReferencedByRelation = m_hasReferencedByRelation ;
1542 result->m_hasReferencesRelation = m_hasReferencesRelation ;
1543 result->m_hasEnumValues = m_hasEnumValues ;
1544 result->m_hasInlineSource = m_hasInlineSource ;
1545 result->m_explExt = m_explExt ;
1546 result->m_tspec = m_tspec ;
1547 result->m_groupHasDocs = m_groupHasDocs ;
1548 result->m_docsForDefinition = m_docsForDefinition ;
1549 result->m_category = m_category ;
1550 result->m_categoryRelation = m_categoryRelation ;
1551 result->m_declFileName = m_declFileName ;
1552 result->m_declLine = m_declLine ;
1553 result->m_declColumn = m_declColumn ;
1554 result->m_numberOfFlowKW = m_numberOfFlowKW ;
1555 result->setDefinitionTemplateParameterLists(m_defTmpArgLists);
1556
1557 result->m_isLinkableCached = 0;
1558 result->m_isConstructorCached = 0;
1559 result->m_isDestructorCached = 0;
1560 return result;
1561}
1562
1563void MemberDefImpl::moveTo(Definition *scope)
1564{
1565 setOuterScope(scope);
1566 if (scope->definitionType()==Definition::TypeClass)
1567 {
1568 m_classDef = toClassDef(scope);
1569 }
1570 else if (scope->definitionType()==Definition::TypeFile)
1571 {
1572 m_fileDef = toFileDef(scope);
1573 }
1574 else if (scope->definitionType()==Definition::TypeModule)
1575 {
1576 m_moduleDef = toModuleDef(scope);
1577 }
1578 else if (scope->definitionType()==Definition::TypeNamespace)
1579 {
1580 m_nspace = toNamespaceDef(scope);
1581 }
1582 m_isLinkableCached = 0;
1583 m_isConstructorCached = 0;
1584}
1585
1586
1591
1592void MemberDefImpl::insertReimplementedBy(MemberDef *md)
1593{
1594 if (m_templateMaster)
1595 {
1596 MemberDefMutable *mdm = toMemberDefMutable(const_cast<MemberDef *>(m_templateMaster));
1597 if (mdm)
1598 {
1599 mdm->insertReimplementedBy(md);
1600 }
1601 }
1602 if (!m_redefinedBy.contains(md))
1603 {
1604 m_redefinedBy.inSort(md);
1605 }
1606}
1607
1608const MemberDef *MemberDefImpl::reimplements() const
1609{
1610 return m_redefines;
1611}
1612
1613const MemberVector &MemberDefImpl::reimplementedBy() const
1614{
1615 return m_redefinedBy;
1616}
1617
1618bool MemberDefImpl::isReimplementedBy(const ClassDef *cd) const
1619{
1620 if (cd)
1621 {
1622 for (const auto &md : m_redefinedBy)
1623 {
1624 const ClassDef *mcd = md->getClassDef();
1625 if (mcd)
1626 {
1627 if (cd==mcd || cd->isBaseClass(mcd,TRUE))
1628 {
1629 return TRUE;
1630 }
1631 }
1632 }
1633 }
1634 return FALSE;
1635}
1636
1637void MemberDefImpl::insertEnumField(MemberDef *md)
1638{
1639 m_enumFields.push_back(md);
1640}
1641
1642bool MemberDefImpl::addExample(const QCString &anchor,const QCString &nameStr, const QCString &file)
1643{
1644 //printf("%s::addExample(%s,%s,%s)\n",qPrint(name()),anchor,nameStr,file);
1645 return m_examples.inSort(Example(anchor,nameStr,file));
1646}
1647
1648bool MemberDefImpl::hasExamples() const
1649{
1650 return !m_examples.empty();
1651}
1652
1653QCString MemberDefImpl::sourceRefName() const
1654{
1655 QCString n = name();
1656 QCString s = getScopeString();
1657
1658 if (!s.isEmpty())
1659 {
1660 n.prepend(s+"::");
1661 }
1662 else if (isStatic() && getFileDef())
1663 {
1664 n.prepend(getFileDef()->name()+":");
1665 }
1666 if (isCallable())
1667 {
1668 n.append(argsString());
1669 }
1670 return n;
1671}
1672
1673QCString MemberDefImpl::getOutputFileBase() const
1674{
1675 bool separateMemberPages = Config_getBool(SEPARATE_MEMBER_PAGES);
1676 bool inlineSimpleClasses = Config_getBool(INLINE_SIMPLE_STRUCTS);
1677 QCString baseName;
1678
1679 //printf("Member: %s: templateMaster=%p group=%p classDef=%p nspace=%p fileDef=%p\n",
1680 // qPrint(name()),m_templateMaster,m_group,m_classDef,
1681 // m_nspace,m_fileDef);
1682 const NamespaceDef *nspace = getNamespaceDef();
1683 const FileDef *fileDef = getFileDef();
1684 const ClassDef *classDef = getClassDef();
1685 const ModuleDef *moduleDef = getModuleDef();
1686 const GroupDef *groupDef = getGroupDef();
1687 if (!m_explicitOutputFileBase.isEmpty())
1688 {
1689 return m_explicitOutputFileBase;
1690 }
1691 else if (templateMaster())
1692 {
1693 return templateMaster()->getOutputFileBase();
1694 }
1695 else if (groupDef)
1696 {
1697 baseName=groupDef->getOutputFileBase();
1698 }
1699 else if (classDef)
1700 {
1701 baseName=classDef->getOutputFileBase();
1702 if (inlineSimpleClasses && classDef->isSimple())
1703 {
1704 return baseName;
1705 }
1706 }
1707 else if (nspace && (nspace->isLinkable() || nspace->isAnonymous()))
1708 {
1709 baseName=nspace->getOutputFileBase();
1710 }
1711 else if (fileDef)
1712 {
1713 baseName=fileDef->getOutputFileBase();
1714 }
1715 else if (moduleDef)
1716 {
1717 baseName=moduleDef->getOutputFileBase();
1718 }
1719
1720 if (baseName.isEmpty())
1721 {
1722 warn(getDefFileName(),getDefLine(),
1723 "Internal inconsistency: member {} does not belong to any container!",name()
1724 );
1725 return "dummy";
1726 }
1727 else if (separateMemberPages && hasDetailedDescription())
1728 {
1729 if (getEnumScope()) // enum value, which is part of enum's documentation
1730 {
1731 baseName+="_"+getEnumScope()->anchor();
1732 }
1733 else
1734 {
1735 baseName+="_"+anchor();
1736 }
1737 }
1738 return baseName;
1739}
1740
1741QCString MemberDefImpl::getReference() const
1742{
1743 QCString ref = DefinitionMixin::getReference();
1744 if (!ref.isEmpty())
1745 {
1746 return ref;
1747 }
1748 const NamespaceDef *nspace = getNamespaceDef();
1749 const FileDef *fileDef = getFileDef();
1750 const ClassDef *classDef = getClassDef();
1751 const ModuleDef *moduleDef = getModuleDef();
1752 const GroupDef *groupDef = getGroupDef();
1753 if (templateMaster())
1754 {
1755 return templateMaster()->getReference();
1756 }
1757 else if (groupDef)
1758 {
1759 return groupDef->getReference();
1760 }
1761 else if (classDef)
1762 {
1763 return classDef->getReference();
1764 }
1765 else if (nspace)
1766 {
1767 return nspace->getReference();
1768 }
1769 else if (moduleDef)
1770 {
1771 return moduleDef->getReference();
1772 }
1773 else if (fileDef)
1774 {
1775 return fileDef->getReference();
1776 }
1777 return "";
1778}
1779
1780QCString MemberDefImpl::anchor() const
1781{
1782 QCString result=m_anc;
1783 if (m_groupAlias) return m_groupAlias->anchor();
1784 if (m_templateMaster) return m_templateMaster->anchor();
1785 if (m_enumScope && m_enumScope!=this) // avoid recursion for C#'s public enum E { E, F }
1786 {
1787 result.prepend(m_enumScope->anchor());
1788 }
1789 if (getGroupDef())
1790 {
1791 if (m_groupMember)
1792 {
1793 result=m_groupMember->anchor();
1794 }
1795 else if (getReference().isEmpty())
1796 {
1797 result.prepend("g");
1798 }
1799 }
1800 return result;
1801}
1802
1803void MemberDefImpl::_computeLinkableInProject()
1804{
1805 AUTO_TRACE("name={}",qualifiedName());
1806 bool extractStatic = Config_getBool(EXTRACT_STATIC);
1807 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
1808 m_isLinkableCached = 2; // linkable
1809 //printf("MemberDefImpl::isLinkableInProject(name=%s)\n",qPrint(name()));
1810 if (isHidden())
1811 {
1812 AUTO_TRACE_ADD("is hidden");
1813 m_isLinkableCached = 1;
1814 return;
1815 }
1816 if (templateMaster())
1817 {
1818 AUTO_TRACE_ADD("has master template");
1819 m_isLinkableCached = templateMaster()->isLinkableInProject() ? 2 : 1;
1820 return;
1821 }
1822 if (isAnonymous())
1823 {
1824 AUTO_TRACE_ADD("name invalid");
1825 m_isLinkableCached = 1; // not a valid or a dummy name
1826 return;
1827 }
1828 if (!hasDocumentation() || isReference())
1829 {
1830 AUTO_TRACE_ADD("no docs or reference");
1831 m_isLinkableCached = 1; // no documentation
1832 return;
1833 }
1834 const GroupDef *groupDef = getGroupDef();
1835 const ClassDef *classDef = getClassDef();
1836 if (groupDef && !groupDef->isLinkableInProject())
1837 {
1838 AUTO_TRACE_ADD("in not linkable group");
1839 m_isLinkableCached = 1; // group but group not linkable
1840 return;
1841 }
1842 if (!groupDef && classDef && !classDef->isLinkableInProject())
1843 {
1844 AUTO_TRACE_ADD("in not linkable class");
1845 m_isLinkableCached = 1; // in class but class not linkable
1846 return;
1847 }
1848 const NamespaceDef *nspace = getNamespaceDef();
1849 const FileDef *fileDef = getFileDef();
1850 if (!groupDef && nspace /*&& m_related==Relationship::Member*/ && !nspace->isLinkableInProject()
1851 && (fileDef==nullptr || !fileDef->isLinkableInProject()))
1852 {
1853 AUTO_TRACE_ADD("in not linkable namespace");
1854 m_isLinkableCached = 1; // in namespace but namespace not linkable
1855 return;
1856 }
1857 if (!groupDef && !nspace &&
1858 /*m_related==Relationship::Member &&*/ !classDef &&
1859 fileDef && !fileDef->isLinkableInProject())
1860 {
1861 AUTO_TRACE_ADD("in not linkable file");
1862 m_isLinkableCached = 1; // in file (and not in namespace) but file not linkable
1863 return;
1864 }
1865 if ((!protectionLevelVisible(m_prot) && m_mtype!=MemberType::Friend) &&
1866 !(m_prot==Protection::Private && (m_virt!=Specifier::Normal || isOverride() || isFinal()) && extractPrivateVirtual))
1867 {
1868 AUTO_TRACE_ADD("private and invisible");
1869 m_isLinkableCached = 1; // hidden due to protection
1870 return;
1871 }
1872 if (m_stat && classDef==nullptr && !extractStatic)
1873 {
1874 AUTO_TRACE_ADD("static and invisible");
1875 m_isLinkableCached = 1; // hidden due to staticness
1876 return;
1877 }
1878 AUTO_TRACE_ADD("linkable");
1879 return; // linkable!
1880}
1881
1887
1893
1898
1904
1910
1911bool MemberDefImpl::isLinkableInProject() const
1912{
1913 if (m_isLinkableCached==0)
1914 {
1915 MemberDefImpl *that = const_cast<MemberDefImpl*>(this);
1916 that->_computeLinkableInProject();
1917 }
1918 ASSERT(m_isLinkableCached>0);
1919 return m_isLinkableCached==2;
1920}
1921
1922bool MemberDefImpl::isLinkable() const
1923{
1924 if (m_templateMaster)
1925 {
1926 return m_templateMaster->isLinkable();
1927 }
1928 else
1929 {
1930 return isLinkableInProject() || isReference();
1931 }
1932}
1933
1934
1939
1940void MemberDefImpl::writeLink(OutputList &ol,
1941 const ClassDef *,const NamespaceDef *,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
1942 bool onlyText) const
1943{
1944 SrcLangExt lang = getLanguage();
1945 bool hideScopeNames = Config_getBool(HIDE_SCOPE_NAMES);
1946 QCString sep = getLanguageSpecificSeparator(lang,TRUE);
1947 QCString n = name();
1948 const ClassDef *classDef = getClassDef();
1949 const NamespaceDef *nspace = getNamespaceDef();
1950 if (!hideScopeNames)
1951 {
1952 if (m_enumScope && m_livesInsideEnum && getGroupDef()!=nullptr)
1953 {
1954 n.prepend(m_enumScope->displayName()+sep);
1955 }
1956 if (classDef && (gd || mod) && !isRelated())
1957 {
1958 n.prepend(classDef->displayName()+sep);
1959 }
1960 else if (nspace && (gd || fd || mod))
1961 {
1962 n.prepend(nspace->displayName()+sep);
1963 }
1964 }
1965
1966 if (isObjCMethod())
1967 {
1968 if (isStatic()) ol.docify("+ "); else ol.docify("- ");
1969 }
1970 if (!onlyText && (isLinkable() || hasDetailedDescription())) // write link
1971 {
1972 if (m_mtype==MemberType::EnumValue && getGroupDef()==nullptr && // enum value is not grouped
1973 getEnumScope() && getEnumScope()->getGroupDef()) // but its container is
1974 {
1975 const GroupDef *enumValGroup = getEnumScope()->getGroupDef();
1976 ol.writeObjectLink(enumValGroup->getReference(),
1977 enumValGroup->getOutputFileBase(),
1978 anchor(),n);
1979 }
1980 else
1981 {
1982 ol.writeObjectLink(getReference(),getOutputFileBase(),anchor(),n);
1983 }
1984 }
1985 else // write only text
1986 {
1987 ol.startBold();
1988 ol.docify(n);
1989 ol.endBold();
1990 }
1991}
1992
1993static std::mutex g_cachedAnonymousTypeMutex;
1994
1995/*! If this member has an anonymous class/struct/union as its type, then
1996 * this method will return the ClassDef that describes this return type.
1997 */
1998ClassDef *MemberDefImpl::getClassDefOfAnonymousType() const
1999{
2000 std::lock_guard<std::mutex> lock(g_cachedAnonymousTypeMutex);
2001 //printf("%s:getClassDefOfAnonymousType() cache=%s\n",qPrint(name()),
2002 // m_cachedAnonymousType?qPrint(m_cachedAnonymousType->name()):"<empty>");
2003 if (m_cachedAnonymousType) return m_cachedAnonymousType;
2004
2005 QCString cname;
2006 if (getClassDef()!=nullptr)
2007 {
2008 cname=getClassDef()->name();
2009 }
2010 else if (getNamespaceDef()!=nullptr)
2011 {
2012 cname=getNamespaceDef()->name();
2013 }
2014 QCString ltype(m_type);
2015 // strip 'friend' keyword from ltype
2016 ltype.stripPrefix("friend ");
2017
2018 // search for the last anonymous scope in the member type
2019 ClassDef *annoClassDef=nullptr;
2020
2021 // match expression if it contains at least one @1 marker, e.g.
2022 // 'struct A::@1::@2::B' matches 'A::@1::@2::B' but 'struct A::B' does not match.
2023 std::string stype = ltype.str();
2024 static const reg::Ex r(R"([\w@:]*@\d+[\w@:]*)");
2025 reg::Match match;
2026 if (reg::search(stype,match,r)) // found anonymous scope in type
2027 {
2028 QCString annName = match.str();
2029
2030 // if inside a class or namespace try to prepend the scope name
2031 if (!cname.isEmpty() && annName.left(cname.length()+2)!=cname+"::")
2032 {
2033 QCString ts=stripAnonymousNamespaceScope(cname+"::"+annName);
2034 annoClassDef=getClass(ts);
2035 }
2036 // if not found yet, try without scope name
2037 if (annoClassDef==nullptr)
2038 {
2039 QCString ts=stripAnonymousNamespaceScope(annName);
2040 annoClassDef=getClass(ts);
2041 }
2042 }
2043 m_cachedAnonymousType = annoClassDef;
2044 return annoClassDef;
2045}
2046
2047/*! This methods returns TRUE iff the brief section (also known as
2048 * declaration section) is visible in the documentation.
2049 */
2050bool MemberDefImpl::isBriefSectionVisible() const
2051{
2052 bool extractStatic = Config_getBool(EXTRACT_STATIC);
2053 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
2054 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
2055 bool briefMemberDesc = Config_getBool(BRIEF_MEMBER_DESC);
2056 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
2057 bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
2058
2059 //printf("Member %s grpId=%d docs=%s file=%s args=%s\n",
2060 // qPrint(name()),
2061 // 0,"", //grpId,grpId==-1?"<none>":Doxygen::memberDocDict[grpId]->data(),
2062 // "", //qPrint(getFileDef()->name()),
2063 // argsString());
2064
2065 bool hasDocs = hasDocumentation();
2066
2067 // only include static members with file/namespace scope if
2068 // explicitly enabled in the config file
2069 bool visibleIfStatic = !(getClassDef()==nullptr &&
2070 isStatic() &&
2071 !extractStatic
2072 );
2073
2074 // only include members is the are documented or
2075 // HIDE_UNDOC_MEMBERS is NO in the config file
2076 bool visibleIfDocumented = (!hideUndocMembers ||
2077 hasDocs ||
2078 isDocumentedFriendClass()
2079 );
2080
2081 // hide members with no detailed description and brief descriptions
2082 // explicitly disabled.
2083 bool visibleIfEnabled = !(hideUndocMembers &&
2084 documentation().isEmpty() &&
2085 !briefMemberDesc &&
2086 !repeatBrief
2087 );
2088
2089 // Hide friend (class|struct|union) declarations if HIDE_FRIEND_COMPOUNDS is true
2090 bool visibleIfFriendCompound = !(hideFriendCompounds &&
2091 isFriend() /*&&
2092 (m_type=="friend class" ||
2093 m_type=="friend struct" ||
2094 m_type=="friend union"
2095 )*/
2096 );
2097
2098 // only include members that are non-private unless EXTRACT_PRIVATE is
2099 // set to YES or the member is part of a group. And as a special case,
2100 // private *documented* virtual members are shown if EXTRACT_PRIV_VIRTUAL
2101 // is set to YES
2102 bool visibleIfPrivate = (protectionLevelVisible(protection()) ||
2103 m_mtype==MemberType::Friend ||
2104 (m_prot==Protection::Private &&
2105 (m_virt!=Specifier::Normal || isOverride() || isFinal()) && extractPrivateVirtual && hasDocs)
2106 );
2107
2108 // hide member if it overrides a member in a superclass and has no
2109 // documentation of its own
2110 //bool visibleIfDocVirtual = !reimplements() ||
2111 // !Config_getBool(INHERIT_DOCS) ||
2112 // hasDocs;
2113
2114 // true if this member is a constructor or destructor
2115 bool cOrDTor = isConstructor() || isDestructor();
2116
2117 // hide default constructors or destructors (no args) without
2118 // documentation
2119 bool visibleIfNotDefaultCDTor = !(cOrDTor &&
2120 (m_defArgList.empty() ||
2121 m_defArgList.front().type == "void"
2122 ) &&
2123 !hasDocs
2124 );
2125
2126
2127 //printf("visibleIfStatic=%d visibleIfDocumented=%d visibleIfEnabled=%d "
2128 // "visibleIfPrivate=%d visibleIfNotDefaultCDTor=%d "
2129 // "visibleIfFriendCompound=%d !annScope=%d\n",
2130 // visibleIfStatic,visibleIfDocumented,
2131 // visibleIfEnabled,visibleIfPrivate,visibleIfNotDefaultCDTor,
2132 // visibleIfFriendCompound,!m_annScope);
2133
2134 bool visible = visibleIfStatic && visibleIfDocumented &&
2135 visibleIfEnabled && visibleIfPrivate &&
2136 /*visibleIfDocVirtual &&*/ visibleIfNotDefaultCDTor &&
2137 visibleIfFriendCompound &&
2138 !m_annScope && !isHidden();
2139 //printf("MemberDefImpl::isBriefSectionVisible() %d\n",visible);
2140 return visible;
2141}
2142
2143QCString MemberDefImpl::getDeclType() const
2144{
2145 SrcLangExt lang = getLanguage();
2146 QCString ltype(m_type);
2147 if (lang==SrcLangExt::Cpp && isEnumerate() && isStrong())
2148 {
2149 if (isEnumStruct())
2150 {
2151 ltype+=" struct";
2152 }
2153 else
2154 {
2155 ltype+=" class";
2156 }
2157 }
2158 if (isTypedef() && getLanguage() != SrcLangExt::Slice)
2159 {
2160 ltype.prepend("typedef ");
2161 }
2162 if (isTypeAlias())
2163 {
2164 if (lang==SrcLangExt::Python)
2165 {
2166 ltype="type";
2167 }
2168 else
2169 {
2170 ltype="using";
2171 }
2172 }
2173 // strip 'friend' keyword from ltype
2174 ltype.stripPrefix("friend ");
2175 if (ltype=="@") // rename type from enum values
2176 {
2177 ltype="";
2178 }
2179 else
2180 {
2181 if (isObjCMethod())
2182 {
2183 ltype.prepend("(");
2184 ltype.append(")");
2185 }
2186 }
2187 return ltype;
2188}
2189
2190void MemberDefImpl::_writeTemplatePrefix(OutputList &ol, const Definition *def,
2191 const ArgumentList &al, bool writeReqClause) const
2192{
2193 ol.docify("template<");
2194 LinkifyTextOptions options;
2195 options.setScope(def).setFileScope(getFileDef()).setSelf(this);
2196 for (auto it = al.begin(); it!=al.end();)
2197 {
2198 Argument a = *it;
2199 linkifyText(TextGeneratorOLImpl(ol),a.type,options);
2200 if (!a.name.isEmpty())
2201 {
2202 ol.docify(" ");
2203 ol.docify(a.name);
2204 }
2205 if (!a.defval.isEmpty())
2206 {
2207 ol.docify(" = ");
2208 ol.docify(a.defval);
2209 }
2210 ++it;
2211 if (it!=al.end()) ol.docify(", ");
2212 }
2213 ol.docify("> ");
2214 if (writeReqClause && !m_requiresClause.isEmpty())
2215 {
2216 ol.lineBreak();
2217 ol.docify("requires ");
2218 linkifyText(TextGeneratorOLImpl(ol), // out
2219 m_requiresClause, // text
2220 LinkifyTextOptions(options).setAutoBreak(true).setBreakThreshold(120));
2221 }
2222}
2223
2224static QCString combineArgsAndException(QCString args,QCString exception)
2225{
2226 if (exception.isEmpty()) return args; // no exception, nothing to combine args
2227 int pos = args.findRev(')');
2228 int eqPos = pos!=-1 ? args.find('=',pos) : -1; // look for '=' in '(args) = something'
2229 if (eqPos==-1) return args+" "+exception; // append exception at the end
2230 return args.left(eqPos)+" "+exception+" "+args.mid(eqPos); // insert exception before =
2231}
2232
2233bool MemberDefImpl::_isAnonymousBitField() const
2234{
2235 return !m_bitfields.isEmpty() && name().startsWith("__pad"); // anonymous bitfield
2236}
2237
2238void MemberDefImpl::writeDeclaration(OutputList &ol,
2239 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod,
2240 bool inGroup, int indentLevel, const ClassDef *inheritedFrom,const QCString &inheritId) const
2241{
2242 //printf("> %s MemberDefImpl::writeDeclaration() inGroup=%d inheritId=%s\n",qPrint(qualifiedName()),inGroup,qPrint(inheritId));
2243
2244 // hide enum value, since they appear already as part of the enum, unless they
2245 // are explicitly grouped.
2246 if (!inGroup && m_mtype==MemberType::EnumValue) return;
2247
2248 const Definition *d=nullptr;
2249 ASSERT (cd!=nullptr || nd!=nullptr || fd!=nullptr || gd!=nullptr || mod!=nullptr); // member should belong to something
2250 if (cd) d=cd;
2251 else if (nd) d=nd;
2252 else if (fd) d=fd;
2253 else d=gd;
2254 if (d==gd || d==mod) // see bug 753608
2255 {
2256 if (getClassDef()) d = getClassDef();
2257 else if (getNamespaceDef()) d = getNamespaceDef();
2258 else if (getFileDef()) d = getFileDef();
2259 }
2260 else if (d==fd) // see issue #9850, namespace member can be shown in file scope as well
2261 {
2262 if (getNamespaceDef()) d = getNamespaceDef();
2263 }
2264 if (d==nullptr)
2265 {
2266 err("No context could be derived for member '{}'\n",name());
2267 return; // should not happen
2268 }
2269
2270 QCString cname = d->name();
2271 QCString cdname = d->displayName();
2272 QCString cfname = getOutputFileBase();
2273
2274 // search for the last anonymous scope in the member type
2275 ClassDef *annoClassDef=getClassDefOfAnonymousType();
2276
2277 ol.startMemberDeclaration();
2278
2279 // start a new member declaration
2280 bool isAnonType = annoClassDef || m_annMemb || m_annEnumType;
2281 OutputGenerator::MemberItemType anonType = isAnonType ? OutputGenerator::MemberItemType::AnonymousStart :
2282 !m_tArgList.empty() ? OutputGenerator::MemberItemType::Templated :
2283 OutputGenerator::MemberItemType::Normal;
2284 ol.startMemberItem(annoClassDef ? QCString() : anchor(), anonType, inheritId);
2285
2286
2287 // If there is no detailed description we need to write the anchor here.
2288 bool detailsVisible = hasDetailedDescription();
2289 bool writeAnchor = (inGroup || getGroupDef()==nullptr) && // only write anchors for member that have no details and are
2290 !detailsVisible && !m_annMemb && // rendered inside the group page or are not grouped at all
2291 inheritId.isEmpty();
2292
2293 if (writeAnchor)
2294 {
2295 QCString doxyArgs=argsString();
2296 QCString doxyName=name();
2297 if (!cname.isEmpty())
2298 {
2299 doxyName.prepend(cdname+getLanguageSpecificSeparator(getLanguage()));
2300 }
2301 ol.startDoxyAnchor(cfname,cname,anchor(),doxyName,doxyArgs);
2302 ol.addLabel(cfname,anchor());
2303 }
2304
2305 if (!detailsVisible)
2306 {
2307 ol.pushGeneratorState();
2308 ol.disable(OutputType::Man);
2309 ol.disable(OutputType::Latex);
2310 ol.disable(OutputType::Docbook);
2311 ol.docify("\n");
2312 ol.popGeneratorState();
2313 }
2314
2315 if (annoClassDef || m_annMemb)
2316 {
2317 for (int j=0;j<indentLevel;j++)
2318 {
2319 ol.writeNonBreakableSpace(3);
2320 }
2321 }
2322
2323 // *** write template lists
2324 if (m_tArgList.hasParameters() && getLanguage()==SrcLangExt::Cpp)
2325 {
2326 if (!isAnonType) ol.startMemberTemplateParams();
2327 _writeTemplatePrefix(ol,d,m_tArgList);
2328 if (!isAnonType) ol.endMemberTemplateParams(anchor(),inheritId);
2329 }
2330
2331
2332 // *** write type
2333 QCString ltype(m_type);
2334 auto lang = getLanguage();
2335 if (isTypedef() && lang != SrcLangExt::Slice)
2336 {
2337 ltype.prepend("typedef ");
2338 }
2339 if (isTypeAlias())
2340 {
2341 if (lang==SrcLangExt::Python)
2342 {
2343 ltype="type";
2344 }
2345 else
2346 {
2347 ltype="using";
2348 }
2349 }
2350 // strip 'friend' keyword from ltype
2351 ltype.stripPrefix("friend ");
2352 static const reg::Ex r(R"(@\d+)");
2353 reg::Match match;
2354 std::string stype = ltype.str();
2355 bool endAnonScopeNeeded=FALSE;
2356 LinkifyTextOptions options;
2357 options.setScope(d).setFileScope(getBodyDef()).setSelf(this);
2358 if (reg::search(stype,match,r)) // member has an anonymous type
2359 {
2360 int i = static_cast<int>(match.position());
2361 int l = static_cast<int>(match.length());
2362 //printf("annoClassDef=%p annMemb=%p scopeName='%s' anonymous='%s'\n",
2363 // annoClassDef,annMemb,qPrint(cname),qPrint(ltype.mid(i,l)));
2364
2365 if (annoClassDef) // type is an anonymous compound
2366 {
2367 int ir=i+l;
2368 //printf("<<<<<<<<<<<<<<\n");
2369 ol.startAnonTypeScope(indentLevel);
2370 annoClassDef->writeDeclaration(ol,m_annMemb,inGroup,indentLevel+1,inheritedFrom,inheritId);
2371 //printf(">>>>>>>>>>>>>> startMemberItem(2)\n");
2372 anonType = OutputGenerator::MemberItemType::AnonymousEnd;
2373 ol.startMemberItem(anchor(),anonType,inheritId);
2374 for (int j=0;j< indentLevel;j++)
2375 {
2376 ol.writeNonBreakableSpace(3);
2377 }
2378 QCString varName=ltype.right(ltype.length()-ir).stripWhiteSpace();
2379 //printf(">>>>>> ltype='%s' varName='%s'\n",qPrint(ltype),qPrint(varName));
2380 ol.docify("}");
2381 if (varName.isEmpty() && isAnonymous())
2382 {
2383 ol.docify(";");
2384 }
2385 else if (!varName.isEmpty() && (varName.at(0)=='*' || varName.at(0)=='&'))
2386 {
2387 ol.docify(" ");
2388 ol.docify(varName);
2389 }
2390 endAnonScopeNeeded=TRUE;
2391 }
2392 else
2393 {
2394 if (getAnonymousEnumType()) // type is an anonymous enum
2395 {
2396 linkifyText(TextGeneratorOLImpl(ol),ltype.left(i),options);
2397 getAnonymousEnumType()->writeEnumDeclaration(ol,cd,nd,fd,gd,mod);
2398 linkifyText(TextGeneratorOLImpl(ol),ltype.right(ltype.length()-i-l),LinkifyTextOptions(options).setAutoBreak(true));
2399 }
2400 else
2401 {
2402 ltype = ltype.left(i) + " { ... } " + removeAnonymousScopes(ltype.right(ltype.length()-i-l));
2403 linkifyText(TextGeneratorOLImpl(ol), ltype, options);
2404 }
2405 }
2406 }
2407 else if (ltype=="@") // rename type from enum values
2408 {
2409 ltype="";
2410 }
2411 else
2412 {
2413 if (isObjCMethod())
2414 {
2415 ltype.prepend("(");
2416 ltype.append(")");
2417 }
2418 linkifyText(TextGeneratorOLImpl(ol),ltype,options);
2419 }
2420 bool htmlOn = ol.isEnabled(OutputType::Html);
2421 if (htmlOn && !ltype.isEmpty())
2422 {
2423 ol.disable(OutputType::Html);
2424 }
2425 if (!ltype.isEmpty()) ol.docify(" ");
2426 if (htmlOn)
2427 {
2428 ol.enable(OutputType::Html);
2429 }
2430
2431 if (m_annMemb)
2432 {
2433 ol.pushGeneratorState();
2434 ol.disableAllBut(OutputType::Html);
2435 ol.writeNonBreakableSpace(3);
2436 ol.popGeneratorState();
2437 }
2438 else
2439 {
2440 ol.insertMemberAlign(m_tArgList.hasParameters());
2441 }
2442
2443 // *** write name
2444 if (!isAnonymous() && !_isAnonymousBitField()) // hide anonymous stuff
2445 {
2446 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
2447 bool extractStatic = Config_getBool(EXTRACT_STATIC);
2448 MemberDefMutable *annMemb = toMemberDefMutable(m_annMemb);
2449 bool visibleIfPrivate = (protectionLevelVisible(protection()) ||
2450 m_mtype==MemberType::Friend ||
2451 (m_prot==Protection::Private &&
2452 (m_virt!=Specifier::Normal || isOverride() || isFinal()) &&
2453 extractPrivateVirtual && hasDocumentation()
2454 ));
2455 //printf("Member name=`%s gd=%p md->groupDef=%p inGroup=%d isLinkable()=%d hasDocumentation=%d\n",qPrint(name()),gd,getGroupDef(),inGroup,isLinkable(),hasDocumentation());
2456 if (!name().isEmpty() && // name valid
2457 (hasDetailedDescription() || isReference()) && // has docs
2458 visibleIfPrivate &&
2459 !(isStatic() && getClassDef()==nullptr && !extractStatic) // hidden due to static-ness
2460 )
2461 {
2462 if (annMemb)
2463 {
2464 //printf("anchor=%s ann_anchor=%s\n",anchor(),annMemb->anchor());
2465 annMemb->writeLink(ol,
2466 annMemb->getClassDef(),
2467 annMemb->getNamespaceDef(),
2468 annMemb->getFileDef(),
2469 annMemb->getGroupDef(),
2470 annMemb->getModuleDef());
2471 }
2472 else
2473 {
2474 //printf("writeLink %s->%d\n",qPrint(name),hasDocumentation());
2475 const ClassDef *rcd = cd;
2476 if (isReference() && getClassDef()) rcd = getClassDef();
2477 writeLink(ol,rcd,nd,fd,gd,mod);
2478 }
2479 }
2480 else if (isDocumentedFriendClass())
2481 // if the member is an undocumented friend declaration for some class,
2482 // then maybe we can link to the class
2483 {
2484 writeLink(ol,getClass(name()),nullptr,nullptr,nullptr,nullptr);
2485 }
2486 else
2487 // there is a brief member description and brief member
2488 // descriptions are enabled or there is no detailed description.
2489 {
2490 const ClassDef *rcd = cd;
2491 if (isReference() && getClassDef()) rcd = getClassDef();
2492 writeLink(ol,rcd,nd,fd,gd,mod,TRUE);
2493 }
2494 }
2495
2496 // *** write arguments
2497 if (!argsString().isEmpty() && !isObjCMethod())
2498 {
2499 if (!isDefine() && !isTypedef()) ol.writeString(" ");
2500 linkifyText(TextGeneratorOLImpl(ol), // out
2501 isDefine() ?
2502 substitute(argsString(),",",", ") :
2503 isTypedef() ?
2504 substitute(argsString(),")(",") (") :
2505 combineArgsAndException(argsString(),excpString()), // text
2506 LinkifyTextOptions(options)
2507 .setArgumentList(&m_defArgList)
2508 .setAutoBreak(m_annMemb!=nullptr)
2509 .setIndentLevel(indentLevel)
2510 );
2511 }
2512
2513 // *** write bitfields
2514 if (!m_bitfields.isEmpty()) // add bitfields
2515 {
2516 linkifyText(TextGeneratorOLImpl(ol),m_bitfields,options);
2517 }
2518 else if (hasOneLineInitializer()
2519 //!init.isEmpty() && initLines==0 && // one line initializer
2520 //((maxInitLines>0 && userInitLines==-1) || userInitLines>0) // enabled by default or explicitly
2521 ) // add initializer
2522 {
2523 if (isTypeAlias()) // using statement
2524 {
2525 ol.writeString(" = ");
2526 linkifyText(TextGeneratorOLImpl(ol),m_initializer.simplifyWhiteSpace(),options);
2527 }
2528 else if (!isDefine())
2529 {
2530 //ol.writeString(" = ");
2531 ol.writeString(" ");
2532 linkifyText(TextGeneratorOLImpl(ol),m_initializer.simplifyWhiteSpace(),options);
2533 }
2534 else
2535 {
2536 ol.writeNonBreakableSpace(3);
2537 linkifyText(TextGeneratorOLImpl(ol),m_initializer,options);
2538 }
2539 }
2540
2541
2542 if ((isObjCMethod() || isObjCProperty()) && isImplementation())
2543 {
2544 ol.startTypewriter();
2545 ol.docify(" [implementation]");
2546 ol.endTypewriter();
2547 }
2548
2549 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
2550
2551 if (isProperty() && (isSettable() || isGettable() ||
2552 isPrivateSettable() || isPrivateGettable() ||
2553 isProtectedSettable() || isProtectedGettable()))
2554 {
2555 ol.writeLatexSpacing();
2556 ol.startTypewriter();
2557 ol.docify(" [");
2558 StringVector sl;
2559
2560 if (isGettable()) sl.emplace_back("get");
2561 if (isProtectedGettable()) sl.emplace_back("protected get");
2562 if (isSettable()) sl.emplace_back("set");
2563 if (isProtectedSettable()) sl.emplace_back("protected set");
2564 if (extractPrivate)
2565 {
2566 if (isPrivateGettable()) sl.emplace_back("private get");
2567 if (isPrivateSettable()) sl.emplace_back("private set");
2568 }
2569 bool first=true;
2570 for (const auto &s : sl)
2571 {
2572 if (!first)
2573 {
2574 ol.docify(", ");
2575 }
2576 first=false;
2577 ol.docify(s);
2578 }
2579 ol.docify("]");
2580 ol.endTypewriter();
2581 }
2582
2583 if (isEvent() && (isAddable() || isRemovable() || isRaisable()))
2584 {
2585 ol.writeLatexSpacing();
2586 ol.startTypewriter();
2587 ol.docify(" [");
2588 StringVector sl;
2589 if (isAddable()) sl.emplace_back("add");
2590 if (isRemovable()) sl.emplace_back("remove");
2591 if (isRaisable()) sl.emplace_back("raise");
2592 bool first=true;
2593 for (const auto &s : sl)
2594 {
2595 if (!first)
2596 {
2597 ol.docify(", ");
2598 }
2599 first=false;
2600 ol.docify(s);
2601 }
2602 ol.docify("]");
2603 ol.endTypewriter();
2604 }
2605
2606 if (writeAnchor)
2607 {
2608 ol.endDoxyAnchor(cfname,anchor());
2609 }
2610
2611 //printf("endMember %s annoClassDef=%p annEnumType=%p\n",
2612 // qPrint(name()),annoClassDef,annEnumType);
2613 ol.endMemberItem(anonType);
2614 if (endAnonScopeNeeded)
2615 {
2616 ol.endAnonTypeScope(indentLevel);
2617 }
2618
2619 // write brief description
2620 if (!briefDescription().isEmpty() &&
2621 Config_getBool(BRIEF_MEMBER_DESC)
2622 )
2623 {
2624 auto parser { createDocParser() };
2625 auto ast { validatingParseDoc(*parser.get(),
2626 briefFile(),
2627 briefLine(),
2628 getOuterScope()?getOuterScope():d,
2629 this,
2630 briefDescription(),
2631 DocOptions()
2632 .setIndexWords(inheritedFrom==nullptr)
2633 .setSingleLine(true))
2634 };
2635 if (!ast->isEmpty())
2636 {
2637 ol.startMemberDescription(anchor(),inheritId);
2638 ol.writeDoc(ast.get(),getOuterScope()?getOuterScope():d,this);
2639 if (detailsVisible) // add More.. link only when both brief and details are visible
2640 {
2641 if (!isAnonymous()) // hide anonymous stuff
2642 {
2643 ol.pushGeneratorState();
2644 ol.disableAllBut(OutputType::Html);
2645 ol.docify(" ");
2646 MemberDefMutable *annMemb = toMemberDefMutable(m_annMemb);
2647 if (annMemb)
2648 {
2649 ol.startTextLink(annMemb->getOutputFileBase(),annMemb->anchor());
2650 ol.parseText(theTranslator->trMore());
2651 ol.endTextLink();
2652 }
2653 ol.popGeneratorState();
2654 }
2655 }
2656 // for RTF we need to add an extra empty paragraph
2657 ol.pushGeneratorState();
2658 ol.disableAllBut(OutputType::RTF);
2659 ol.startParagraph();
2660 ol.endParagraph();
2661 ol.popGeneratorState();
2662 ol.endMemberDescription();
2663 }
2664 }
2665
2666 ol.endMemberDeclaration(anchor(),inheritId);
2667
2668 warnIfUndocumented();
2669 //printf("< %s MemberDefImpl::writeDeclaration() inGroup=%d\n",qPrint(qualifiedName()),inGroup);
2670}
2671
2672static std::mutex g_hasDetailedDescriptionMutex;
2673
2674bool MemberDefImpl::hasDetailedDescription() const
2675{
2676 std::lock_guard<std::mutex> lock(g_hasDetailedDescriptionMutex);
2677 //printf(">hasDetailedDescription(cached=%d)\n",m_hasDetailedDescriptionCached);
2678 if (!m_hasDetailedDescriptionCached)
2679 {
2680 bool extractAll = Config_getBool(EXTRACT_ALL);
2681 bool alwaysDetailedSec = Config_getBool(ALWAYS_DETAILED_SEC);
2682 bool repeatBrief = Config_getBool(REPEAT_BRIEF);
2683 bool briefMemberDesc = Config_getBool(BRIEF_MEMBER_DESC);
2684 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
2685 bool extractStatic = Config_getBool(EXTRACT_STATIC);
2686 bool extractPrivateVirtual = Config_getBool(EXTRACT_PRIV_VIRTUAL);
2687 bool inlineSources = hasInlineSource();
2688
2689 // the member has detailed documentation because the user added some comments
2690 bool docFilter =
2691 // extract all is enabled
2692 extractAll ||
2693 // has detailed docs
2694 !documentation().isEmpty() ||
2695 // has inbody docs
2696 !inbodyDocumentation().isEmpty() ||
2697 // is an enum with values that are documented
2698 (isEnumerate() && hasDocumentedEnumValues()) ||
2699 // is documented enum value
2700 (m_mtype==MemberType::EnumValue && !briefDescription().isEmpty()) ||
2701 // has brief description that is part of the detailed description
2702 (!briefDescription().isEmpty() && // has brief docs
2703 (alwaysDetailedSec && // they are visible in
2704 (repeatBrief || // detailed section or
2705 !briefMemberDesc // they are explicitly not
2706 ) // shown in brief section
2707 )
2708 ) ||
2709 // has one or more documented arguments
2710 (m_templateMaster ?
2711 m_templateMaster->argumentList().hasDocumentation() :
2712 m_defArgList.hasDocumentation()) ||
2713 (m_templateMaster ?
2714 m_templateMaster->templateArguments().hasTemplateDocumentation() :
2715 m_tArgList.hasTemplateDocumentation()) ||
2716 // user-specified qualifiers
2717 !m_qualifiers.empty();
2718
2719 // generate function guard
2720 // ================== =======
2721 // _writeGroupInclude -> ignored in calculation
2722 // multiLineInitializer() -> hasMultiLineInitializer()
2723 // _writeReimplements -> _isReimplements()
2724 // _writeReimplementedBy -> _countReimplementedBy()>0
2725 // _writeExamples -> hasExamples()
2726 // _writeTypeConstraints -> m_typeConstraints.hasParameters()
2727 // writeSourceDef -> !getSourceFileBase().isEmpty();
2728 // writeInlineCode -> hasInlineSource() && hasSources()
2729 // writeSourceRefs -> hasReferencesRelation() && hasSourceRefs()
2730 // writeSourceReffedBy -> hasReferencedByRelation() && hasSourceReffedBy()
2731 // _writeCallGraph -> _hasVisibleCallGraph()
2732 // _writeCallerGraph -> _hasVisibleCallerGraph()
2733
2734 // the member has detailed documentation because there is some generated info
2735 bool docInfo =
2736 // has a multi-line initialization block
2737 (hasMultiLineInitializer()) ||
2738 // reimplements / reimplemented by
2739 _isReimplements() || (_countReimplementedBy() > 0) ||
2740 // examples
2741 hasExamples() ||
2742 // type constraints
2743 m_typeConstraints.hasParameters() ||
2744 // has source definition
2745 !getSourceFileBase().isEmpty() ||
2746 // has inline sources
2747 (inlineSources && hasSources()) ||
2748 // has references
2749 (hasReferencesRelation() && hasSourceRefs()) ||
2750 (hasReferencedByRelation() && hasSourceReffedBy()) ||
2751 // call graph
2752 _hasVisibleCallGraph() ||
2753 // caller graph
2754 _hasVisibleCallerGraph() ||
2755 // requirement references
2756 hasRequirementRefs();
2757
2758 if (!hideUndocMembers) // if HIDE_UNDOC_MEMBERS is NO we also show the detailed section
2759 // if there is only some generated info
2760 {
2761 docFilter = docFilter || docInfo;
2762 }
2763
2764 // this is not a global static or global statics should be extracted
2765 bool staticFilter = getClassDef()!=nullptr || !isStatic() || extractStatic;
2766
2767 // a module does not contain details for members, so either the namespace or file should be linkable
2768 bool moduleFilter = getModuleDef()==nullptr || (getFileDef() && getFileDef()->isLinkable()) ||
2769 (getNamespaceDef() && getNamespaceDef()->isLinkable());
2770
2771 // only include members that are non-private unless EXTRACT_PRIVATE is
2772 // set to YES or the member is part of a group
2773 bool privateFilter = protectionLevelVisible(protection()) || m_mtype==MemberType::Friend ||
2774 (m_prot==Protection::Private && (m_virt!=Specifier::Normal || isOverride() || isFinal()) && extractPrivateVirtual);
2775
2776 // hide friend (class|struct|union) member if HIDE_FRIEND_COMPOUNDS
2777 // is true
2778 bool friendCompoundFilter = !(Config_getBool(HIDE_FRIEND_COMPOUNDS) && isFriend());
2779
2780 m_detailedDescriptionCachedValue =
2781 (docFilter && staticFilter && moduleFilter && privateFilter && friendCompoundFilter && !isHidden());
2782 //printf("docFilter=%d docInfo=%d staticFilter=%d privateFilter=%d friendCompoundFilter=%d !isHidden()=%d",
2783 // docFilter,docInfo,staticFilter,privateFilter,friendCompoundFilter,!isHidden());
2784 m_hasDetailedDescriptionCached = true;
2785 }
2786 //printf("<hasDetailedDescription(cached=%d)\n",m_hasDetailedDescriptionCached);
2787 return m_detailedDescriptionCachedValue;
2788}
2789
2790bool MemberDefImpl::isDetailedSectionVisible(MemberListContainer container) const
2791{
2792 bool separateMemPages = Config_getBool(SEPARATE_MEMBER_PAGES);
2793 bool inlineSimpleStructs = Config_getBool(INLINE_SIMPLE_STRUCTS);
2794 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
2795 bool groupFilter = getGroupDef()==nullptr || container==MemberListContainer::Group || separateMemPages;
2796 bool fileFilter = getNamespaceDef()==nullptr || !getNamespaceDef()->isLinkable() || container!=MemberListContainer::File;
2797 bool simpleFilter = (hasBriefDescription() || !hideUndocMembers) && inlineSimpleStructs &&
2798 getClassDef()!=nullptr && getClassDef()->isSimple();
2799
2800 bool visible = hasDetailedDescription() && groupFilter && fileFilter &&
2801 !isReference();
2802 bool result = visible || simpleFilter;
2803 //printf("%s::isDetailedSectionVisible: %d groupFilter=%d fileFilter=%d\n",
2804 // qPrint(name()),result,groupFilter,fileFilter);
2805 return result;
2806}
2807
2808StringVector MemberDefImpl::getLabels(const Definition *container) const
2809{
2810 StringVector sl;
2811 bool inlineInfo = Config_getBool(INLINE_INFO);
2812
2813 Specifier lvirt=virtualness();
2814 if ((!isObjCMethod() || isOptional() || isRequired()) &&
2815 (protection()!=Protection::Public || lvirt!=Specifier::Normal ||
2816 isFriend() || isRelated() ||
2817 (isInline() && inlineInfo) ||
2818 isSignal() || isSlot() ||
2819 isStatic() || isExternal() ||
2820 isExported() ||
2821 (getClassDef() && getClassDef()!=container && container->definitionType()==TypeClass) ||
2822 TypeSpecifier(m_memSpec).setInline(false)!=TypeSpecifier()
2823 )
2824 )
2825 {
2826 // write the member specifier list
2827 //ol.writeLatexSpacing();
2828 //ol.startTypewriter();
2829 //ol.docify(" [");
2830 SrcLangExt lang = getLanguage();
2831 bool optVhdl = lang==SrcLangExt::VHDL;
2832 bool extractPrivate = Config_getBool(EXTRACT_PRIVATE);
2833 if (optVhdl)
2834 {
2835 sl.push_back(theTranslator->trVhdlType(getVhdlSpecifiers(),TRUE).str());
2836 }
2837 else
2838 {
2839 if (isFriend()) sl.emplace_back("friend");
2840 else if (isRelated()) sl.emplace_back("related");
2841 else
2842 {
2843 if (isExternal()) sl.emplace_back("extern");
2844 if (inlineInfo && isInline()) sl.emplace_back("inline");
2845 if (isExplicit()) sl.emplace_back("explicit");
2846 if (isMutable()) sl.emplace_back("mutable");
2847 if (isThreadLocal()) sl.emplace_back("thread_local");
2848 if (isStatic()) sl.emplace_back("static");
2849 if (isGettable()) sl.emplace_back("get");
2850 if (isProtectedGettable()) sl.emplace_back("protected get");
2851 if (isSettable()) sl.emplace_back("set");
2852 if (isProtectedSettable()) sl.emplace_back("protected set");
2853 if (extractPrivate)
2854 {
2855 if (isPrivateGettable()) sl.emplace_back("private get");
2856 if (isPrivateSettable()) sl.emplace_back("private set");
2857 }
2858 if (isNoDiscard()) sl.emplace_back("nodiscard");
2859 if (isConstExpr()) sl.emplace_back("constexpr");
2860 if (isConstEval()) sl.emplace_back("consteval");
2861 if (isConstInit()) sl.emplace_back("constinit");
2862 if (isAddable()) sl.emplace_back("add");
2863 if (!isUNOProperty() && isRemovable()) sl.emplace_back("remove");
2864 if (isRaisable()) sl.emplace_back("raise");
2865 if (isReadable()) sl.emplace_back("read");
2866 if (isWritable()) sl.emplace_back("write");
2867 if (isFinal()) sl.emplace_back("final");
2868 if (isAbstract()) sl.emplace_back("abstract");
2869 if (isOverride()) sl.emplace_back("override");
2870 if (isInitonly()) sl.emplace_back("initonly");
2871 if (isSealed()) sl.emplace_back("sealed");
2872 if (isNew()) sl.emplace_back("new");
2873 if (isOptional()) sl.emplace_back("optional");
2874 if (isRequired()) sl.emplace_back("required");
2875 if (isExported()) sl.emplace_back("export");
2876
2877 if (isNonAtomic()) sl.emplace_back("nonatomic");
2878 else if (isObjCProperty()) sl.emplace_back("atomic");
2879
2880 // mutual exclusive Objective 2.0 property attributes
2881 if (isAssign()) sl.emplace_back("assign");
2882 else if (isCopy()) sl.emplace_back("copy");
2883 else if (isRetain()) sl.emplace_back("retain");
2884 else if (isWeak()) sl.emplace_back("weak");
2885 else if (lang!=SrcLangExt::CSharp && isStrong()) sl.emplace_back("strong");
2886 else if (isUnretained()) sl.emplace_back("unsafe_unretained");
2887
2888 if (!isObjCMethod())
2889 {
2890 if (protection()==Protection::Protected) sl.emplace_back("protected");
2891 else if (protection()==Protection::Private) sl.emplace_back("private");
2892 else if (protection()==Protection::Package) sl.emplace_back("package");
2893
2894 if (lvirt==Specifier::Virtual) sl.emplace_back("virtual");
2895 else if (lvirt==Specifier::Pure) sl.emplace_back("pure virtual");
2896 if (isSignal()) sl.emplace_back("signal");
2897 if (isSlot()) sl.emplace_back("slot");
2898 if (isDefault()) sl.emplace_back("default");
2899 if (isDelete()) sl.emplace_back("delete");
2900 if (isNoExcept()) sl.emplace_back("noexcept");
2901 if (isAttribute()) sl.emplace_back("attribute");
2902 if (isUNOProperty()) sl.emplace_back("property");
2903 if (isReadonly()) sl.emplace_back("readonly");
2904 if (isBound()) sl.emplace_back("bound");
2905 if (isUNOProperty() && isRemovable()) sl.emplace_back("removable");
2906 if (isConstrained()) sl.emplace_back("constrained");
2907 if (isTransient()) sl.emplace_back("transient");
2908 if (isMaybeVoid()) sl.emplace_back("maybevoid");
2909 if (isMaybeDefault()) sl.emplace_back("maybedefault");
2910 if (isMaybeAmbiguous()) sl.emplace_back("maybeambiguous");
2911 if (isPublished()) sl.emplace_back("published"); // enum
2912 }
2913 if (isObjCProperty() && isImplementation())
2914 {
2915 sl.emplace_back("implementation");
2916 }
2917 }
2918 if (getClassDef() &&
2919 container->definitionType()==TypeClass &&
2920 getClassDef()!=container &&
2921 !isRelated()
2922 )
2923 {
2924 sl.emplace_back("inherited");
2925 }
2926 }
2927 }
2928 else if (isObjCMethod() && isImplementation())
2929 {
2930 sl.emplace_back("implementation");
2931 }
2932
2933 for (const auto &sx : m_qualifiers)
2934 {
2935 bool alreadyAdded = std::find(sl.begin(), sl.end(), sx) != sl.end();
2936 if (!alreadyAdded)
2937 {
2938 sl.push_back(sx);
2939 }
2940 }
2941
2942 return sl;
2943}
2944
2945void MemberDefImpl::_writeCallGraph(OutputList &ol) const
2946{
2947 // write call graph
2948 if (_hasVisibleCallGraph())
2949 {
2950 DotCallGraph callGraph(this,FALSE);
2951 if (callGraph.isTooBig())
2952 {
2953 warn_uncond("Call graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
2954 qualifiedName(), callGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
2955 }
2956 else if (!callGraph.isTrivial())
2957 {
2958 msg("Generating call graph for function {}\n",qualifiedName());
2959 ol.disable(OutputType::Man);
2960 ol.startCallGraph();
2961 ol.parseText(theTranslator->trCallGraph());
2962 ol.endCallGraph(callGraph);
2963 ol.enableAll();
2964 }
2965 }
2966}
2967
2968void MemberDefImpl::_writeCallerGraph(OutputList &ol) const
2969{
2970 if (_hasVisibleCallerGraph())
2971 {
2972 DotCallGraph callerGraph(this, TRUE);
2973 if (callerGraph.isTooBig())
2974 {
2975 warn_uncond("Caller graph for '{}' not generated, too many nodes ({}), threshold is {}. Consider increasing DOT_GRAPH_MAX_NODES.\n",
2976 qualifiedName(), callerGraph.numNodes(), Config_getInt(DOT_GRAPH_MAX_NODES));
2977 }
2978 else if (!callerGraph.isTrivial())
2979 {
2980 msg("Generating caller graph for function {}\n",qualifiedName());
2981 ol.disable(OutputType::Man);
2982 ol.startCallGraph();
2983 ol.parseText(theTranslator->trCallerGraph());
2984 ol.endCallGraph(callerGraph);
2985 ol.enableAll();
2986 }
2987 }
2988}
2989
2990bool MemberDefImpl::_isReimplements() const
2991{
2992 const MemberDef *bmd=reimplements();
2993 const ClassDef *bcd=nullptr;
2994 if (bmd && (bcd=bmd->getClassDef()))
2995 {
2996 // write class that contains a member that is reimplemented by this one
2997 if (bcd->isLinkable())
2998 {
2999 return true;
3000 }
3001 }
3002 return false;
3003}
3004void MemberDefImpl::_writeReimplements(OutputList &ol) const
3005{
3006 const MemberDef *bmd=reimplements();
3007 const ClassDef *bcd=nullptr;
3008 if (bmd && (bcd=bmd->getClassDef()))
3009 {
3010 // write class that contains a member that is reimplemented by this one
3011 if (bcd->isLinkable())
3012 {
3013 ol.startParagraph();
3014 QCString reimplFromLine;
3015 if (bmd->virtualness()!=Specifier::Pure && bcd->compoundType()!=ClassDef::Interface)
3016 {
3017 reimplFromLine = theTranslator->trReimplementedFromList(1);
3018 }
3019 else
3020 {
3021 reimplFromLine = theTranslator->trImplementedFromList(1);
3022 }
3023 int markerPos = reimplFromLine.find("@0");
3024 if (markerPos!=-1) // should always pass this.
3025 {
3026 ol.parseText(reimplFromLine.left(markerPos)); //text left from marker
3027 if (bmd->isLinkable()) // replace marker with link
3028 {
3029 //Definition *bd=bmd->group;
3030 //if (bd==0) bd=bcd;
3031 ol.writeObjectLink(bmd->getReference(),bmd->getOutputFileBase(),
3032 bmd->anchor(),bcd->displayName());
3033
3034 //ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
3035 // bmd->anchor(),bcd->name());
3036 if ( bmd->isLinkableInProject() )
3037 {
3038 writePageRef(ol,bmd->getOutputFileBase(),bmd->anchor());
3039 }
3040 }
3041 else
3042 {
3043 ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
3044 QCString(),bcd->displayName());
3045 if (bcd->isLinkableInProject()/* && !Config_getBool(PDF_HYPERLINKS)*/ )
3046 {
3047 writePageRef(ol,bcd->getOutputFileBase(),bcd->anchor());
3048 }
3049 }
3050 ol.parseText(reimplFromLine.right(
3051 reimplFromLine.length()-markerPos-2)); // text right from marker
3052
3053 }
3054 else
3055 {
3056 err("translation error: no marker in trReimplementsFromList()\n");
3057 }
3058 ol.endParagraph();
3059 }
3060 }
3061}
3062
3063size_t MemberDefImpl::_countReimplementedBy() const
3064{
3065 const MemberVector &bml=reimplementedBy();
3066 size_t count=0;
3067 for (const auto &bmd : bml)
3068 {
3069 const ClassDef *bcd=bmd->getClassDef();
3070 // count the members that directly inherit from md and for
3071 // which the member and class are visible in the docs.
3072 if ( bcd && bmd->isLinkable() && bcd->isLinkable() )
3073 {
3074 count++;
3075 }
3076 }
3077 return count;
3078}
3079
3080void MemberDefImpl::_writeReimplementedBy(OutputList &ol) const
3081{
3082 const MemberVector &bml=reimplementedBy();
3083 size_t count = _countReimplementedBy();
3084 if (count>0)
3085 {
3086 auto replaceFunc = [&bml,&ol](size_t entryIndex)
3087 {
3088 size_t cnt=0;
3089 auto it = bml.begin();
3090 // find the entryIndex-th documented entry in the inheritance list.
3091 const MemberDef *bmd = nullptr;
3092 const ClassDef *bcd = nullptr;
3093 while (it!=bml.end())
3094 {
3095 bmd = *it;
3096 bcd = bmd->getClassDef();
3097 if ( bmd->isLinkable() && bcd->isLinkable())
3098 {
3099 if (cnt==entryIndex) break;
3100 cnt++;
3101 }
3102 ++it;
3103 }
3104
3105 if (bcd && bmd) // write link for marker
3106 {
3107 //ol.writeObjectLink(bcd->getReference(),bcd->getOutputFileBase(),
3108 // bmd->anchor(),bcd->name());
3109 ol.writeObjectLink(bmd->getReference(),bmd->getOutputFileBase(),
3110 bmd->anchor(),bcd->displayName());
3111
3112 if (bmd->isLinkableInProject() )
3113 {
3114 writePageRef(ol,bmd->getOutputFileBase(),bmd->anchor());
3115 }
3116 }
3117 };
3118
3119 QCString reimplInLine;
3120 if (m_virt==Specifier::Pure || (getClassDef() && getClassDef()->compoundType()==ClassDef::Interface))
3121 {
3122 reimplInLine = theTranslator->trImplementedInList(static_cast<int>(count));
3123 }
3124 else
3125 {
3126 reimplInLine = theTranslator->trReimplementedInList(static_cast<int>(count));
3127 }
3128
3129 // write the list of classes that overwrite this member
3130 ol.startParagraph();
3131 writeMarkerList(ol,
3132 reimplInLine.str(),
3133 count,
3134 replaceFunc);
3135 ol.endParagraph();
3136 }
3137}
3138
3139void MemberDefImpl::_writeCategoryRelation(OutputList &ol) const
3140{
3141 if (getClassDef()) // this should be a member of a class/category
3142 {
3143 //printf("%s: category %s relation %s class=%s categoryOf=%s\n",
3144 // qPrint(name()),
3145 // m_category ? qPrint(m_category->name()) : "<none>",
3146 // m_categoryRelation ? qPrint(m_categoryRelation->name()) : "<none>",
3147 // qPrint(m_classDef->name()),
3148 // m_classDef->categoryOf() ? qPrint(m_classDef->categoryOf()->name()) : "<none>"
3149 // );
3150 QCString text;
3151 QCString ref;
3152 QCString file;
3153 QCString anc;
3154 QCString name;
3155 int i=-1;
3156 if (m_categoryRelation && m_categoryRelation->isLinkable())
3157 {
3158 if (m_category)
3159 {
3160 // this member is in a normal class and implements method categoryRelation from category
3161 // so link to method 'categoryRelation' with 'provided by category 'category' text.
3162 text = theTranslator->trProvidedByCategory();
3163 name = m_category->displayName();
3164 }
3165 else if (getClassDef()->categoryOf())
3166 {
3167 // this member is part of a category so link to the corresponding class member of the class we extend
3168 // so link to method 'categoryRelation' with 'extends class 'classDef->categoryOf()'
3169 text = theTranslator->trExtendsClass();
3170 name = getClassDef()->categoryOf()->displayName();
3171 }
3172 i=text.find("@0");
3173 if (i!=-1)
3174 {
3175 const MemberDef *md = m_categoryRelation;
3176 ref = md->getReference();
3177 file = md->getOutputFileBase();
3178 anc = md->anchor();
3179 }
3180 }
3181 if (i!=-1 && !name.isEmpty())
3182 {
3183 ol.startParagraph();
3184 ol.parseText(text.left(i));
3185 ol.writeObjectLink(ref,file,anc,name);
3186 ol.parseText(text.mid(i+2));
3187 ol.endParagraph();
3188 }
3189 }
3190}
3191
3192void MemberDefImpl::_writeExamples(OutputList &ol) const
3193{
3194 // write the list of examples that use this member
3195 if (hasExamples())
3196 {
3197 ol.startExamples();
3198 ol.startDescForItem();
3199 writeExamples(ol,m_examples);
3200 ol.endDescForItem();
3201 ol.endExamples();
3202 }
3203}
3204
3205void MemberDefImpl::_writeTypeConstraints(OutputList &ol) const
3206{
3207 if (m_typeConstraints.hasParameters())
3208 {
3209 writeTypeConstraints(ol,this,m_typeConstraints);
3210 }
3211}
3212
3213void MemberDefImpl::_writeEnumValues(OutputList &ol,const Definition *container,
3214 const QCString &cfname,const QCString &ciname,
3215 const QCString &cname) const
3216{
3217 // For enum, we also write the documented enum values
3218 if (isEnumerate())
3219 {
3220 bool first=true;
3221 //printf("** %s: enum values=%zu\n",qPrint(name()),enumFieldList().size());
3222 bool hasInits = false;
3223 if (hasEnumValues())
3224 {
3225 for (const auto &fmd : enumFieldList())
3226 {
3227 if (fmd->isLinkable())
3228 {
3229 if (!fmd->initializer().isEmpty())
3230 {
3231 hasInits = true;
3232 break;
3233 }
3234 }
3235 }
3236 }
3237 for (const auto &fmd : enumFieldList())
3238 {
3239 //printf("Enum %p: isLinkable()=%d\n",fmd,fmd->isLinkable());
3240 if (fmd->isLinkable())
3241 {
3242 if (first)
3243 {
3244 ol.startDescTable(theTranslator->trEnumerationValues(),hasInits);
3245 first=false;
3246 }
3247
3248 ol.startDescTableRow();
3249 ol.addIndexItem(fmd->name(),ciname);
3250 ol.addIndexItem(ciname,fmd->name());
3251
3252 ol.startDescTableTitle();
3253 ol.startDoxyAnchor(cfname,cname,fmd->anchor(),fmd->name(),fmd->argsString());
3254 ol.addLabel(cfname,fmd->anchor());
3255 ol.docify(fmd->name());
3256 ol.disableAllBut(OutputType::Man);
3257 ol.writeString(" ");
3258 ol.enableAll();
3259 ol.endDoxyAnchor(cfname,fmd->anchor());
3260 ol.endDescTableTitle();
3261 if (hasInits)
3262 {
3263 ol.startDescTableInit();
3264 if (!fmd->initializer().isEmpty())
3265 {
3266 QCString initStr = fmd->initializer().stripWhiteSpace();
3267 if (initStr.startsWith("=")) initStr = initStr.mid(1).stripWhiteSpace();
3268 ol.disableAllBut(OutputType::Man);
3269 ol.writeString("(");
3270 ol.enableAll();
3271 ol.docify(initStr);
3272 ol.disableAllBut(OutputType::Man);
3273 ol.writeString(")");
3274 ol.enableAll();
3275 }
3276 ol.endDescTableInit();
3277 }
3278 ol.startDescTableData();
3279
3280 bool hasBrief = !fmd->briefDescription().isEmpty();
3281 bool hasDetails = !fmd->documentation().isEmpty();
3282
3283 if (hasBrief)
3284 {
3285 ol.generateDoc(fmd->briefFile(),
3286 fmd->briefLine(),
3287 getOuterScope()?getOuterScope():container,
3288 fmd,
3289 fmd->briefDescription(),
3290 DocOptions()
3291 .setIndexWords(true));
3292 }
3293 if (hasDetails)
3294 {
3295 ol.generateDoc(fmd->docFile(),
3296 fmd->docLine(),
3297 getOuterScope()?getOuterScope():container,
3298 fmd,
3299 fmd->documentation()+"\n",
3300 DocOptions()
3301 .setIndexWords(true));
3302 }
3303 ol.endDescTableData();
3304 ol.endDescTableRow();
3305 }
3306 }
3307 if (!first)
3308 {
3309 ol.endDescTable();
3310 }
3311 }
3312}
3313
3314// match from the start of the scope until the last marker
3315static const reg::Ex reAnonymous(R"([\w:@]*@\d+)");
3316
3317QCString MemberDefImpl::displayDefinition() const
3318{
3319 QCString ldef = definition();
3320 QCString title = name();
3321 if (isEnumerate())
3322 {
3323 if (isAnonymous())
3324 {
3325 ldef = title = "anonymous enum";
3326 if (!m_enumBaseType.isEmpty())
3327 {
3328 ldef+=" : "+m_enumBaseType;
3329 }
3330 }
3331 else
3332 {
3333 ldef.prepend("enum ");
3334 if (isSliceLocal())
3335 {
3336 ldef.prepend("local ");
3337 }
3338 }
3339 }
3340 else if (isEnumValue())
3341 {
3342 if (isAnonymous())
3343 {
3344 ldef=ldef.mid(2);
3345 }
3346 }
3347
3348 std::string sdef = ldef.str();
3349 reg::Match match;
3350 if (reg::search(sdef,match,reAnonymous))
3351 {
3352 ldef = match.prefix().str() + " { ... } " + removeAnonymousScopes(match.suffix().str());
3353 }
3354
3355 const ClassDef *cd=getClassDef();
3356 if (cd && cd->isObjectiveC())
3357 {
3358 // strip scope name
3359 int ep = ldef.find("::");
3360 if (ep!=-1)
3361 {
3362 int sp=ldef.findRev(' ',ep);
3363 if (sp!=-1)
3364 {
3365 ldef=ldef.left(sp+1)+ldef.mid(ep+2);
3366 }
3367 }
3368 // strip keywords
3369 int dp = ldef.find(':');
3370 if (dp!=-1)
3371 {
3372 ldef=ldef.left(dp+1);
3373 }
3374 int l=static_cast<int>(ldef.length());
3375 //printf("start >%s<\n",qPrint(ldef));
3376 int i=l-1;
3377 while (i>=0 && (isId(ldef.at(i)) || ldef.at(i)==':')) i--;
3378 while (i>=0 && isspace(static_cast<uint8_t>(ldef.at(i)))) i--;
3379 if (i>0)
3380 {
3381 // insert branches around the type
3382 ldef = "("+ldef.left(i+1)+")"+ldef.mid(i+1);
3383 }
3384 //printf("end >%s< i=%d\n",qPrint(ldef),i);
3385 if (isStatic()) ldef.prepend("+ "); else ldef.prepend("- ");
3386 }
3387 SrcLangExt lang = getLanguage();
3388 QCString sep = getLanguageSpecificSeparator(lang,TRUE);
3389 return substitute(ldef,"::",sep);
3390}
3391
3392void MemberDefImpl::_writeGroupInclude(OutputList &ol,bool inGroup) const
3393{
3394 // only write out the include file if this is not part of a class or file
3395 // definition
3396 bool showGroupedMembInc = Config_getBool(SHOW_GROUPED_MEMB_INC);
3397 bool forceLocalIncludes = Config_getBool(FORCE_LOCAL_INCLUDES);
3398 const FileDef *fd = getFileDef();
3399 QCString nm;
3400 if (inGroup && fd && showGroupedMembInc)
3401 {
3402 if (!Config_getList(STRIP_FROM_INC_PATH).empty())
3403 {
3404 nm = stripFromIncludePath(fd->absFilePath());
3405 }
3406 else
3407 {
3408 nm = fd->name();
3409 }
3410 }
3411 if (!nm.isEmpty())
3412 {
3413 ol.startParagraph();
3414 ol.startTypewriter();
3415 SrcLangExt lang = getLanguage();
3416 bool isIDLorJava = lang==SrcLangExt::IDL || lang==SrcLangExt::Java;
3417 if (isIDLorJava)
3418 {
3419 ol.docify("import ");
3420 }
3421 else
3422 {
3423 ol.docify("#include ");
3424 }
3425
3426 if (isIDLorJava || forceLocalIncludes) ol.docify("\""); else ol.docify("<");
3427
3428 if (fd->isLinkable())
3429 {
3430 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),fd->anchor(),nm);
3431 }
3432 else
3433 {
3434 ol.docify(nm);
3435 }
3436
3437 if (isIDLorJava || forceLocalIncludes) ol.docify("\""); else ol.docify(">");
3438
3439 ol.endTypewriter();
3440 ol.endParagraph();
3441 }
3442}
3443
3444void MemberDefImpl::_writeMultiLineInitializer(OutputList &ol,const QCString &scopeName) const
3445{
3446 //printf("md=%s initLines=%d init='%s'\n",qPrint(name()),initLines,qPrint(init));
3447 ol.startBold();
3448 if (m_mtype==MemberType::Define)
3449 ol.parseText(theTranslator->trDefineValue());
3450 else
3451 ol.parseText(theTranslator->trInitialValue());
3452 ol.endBold();
3453 QCString langCorrected = getDefFileExtension();
3454 SrcLangExt srcLangExt = getLanguageFromFileName(getDefFileExtension());
3455 if (srcLangExt == SrcLangExt::Lex)
3456 {
3457 langCorrected = ".doxygen_lex_c";
3458 srcLangExt = SrcLangExt::Cpp;
3459 }
3460 auto intf = Doxygen::parserManager->getCodeParser(langCorrected);
3461 intf->resetCodeParserState();
3462 auto &codeOL = ol.codeGenerators();
3463 codeOL.startCodeFragment("DoxyCode");
3464 intf->parseCode(codeOL,scopeName,m_initializer,srcLangExt,Config_getBool(STRIP_CODE_COMMENTS),
3465 CodeParserOptions()
3466 .setFileDef(getFileDef())
3467 .setInlineFragment(true)
3468 .setMemberDef(this)
3469 .setShowLineNumbers(false)
3470 .setSearchCtx(this)
3471 );
3472 codeOL.endCodeFragment("DoxyCode");
3473}
3474
3475/*! Writes the "detailed documentation" section of this member to
3476 * all active output formats.
3477 */
3478void MemberDefImpl::writeDocumentation(const MemberList *ml,
3479 int memCount,int memTotal,
3480 OutputList &ol,
3481 const QCString &scName,
3482 const Definition *container,
3483 bool inGroup,
3484 bool /* showEnumValues */,
3485 bool showInline
3486 ) const
3487{
3488 // if this member is in a group find the real scope name.
3489 bool hasParameterList = FALSE;
3490
3491 //printf("MemberDefImpl::writeDocumentation(): name='%s' hasDocs='%d' containerType=%d inGroup=%d sectionLinkable=%d\n",
3492 // qPrint(name()),hasDocs,container->definitionType(),inGroup,hasDetailedDescription());
3493
3494 //if ( !hasDocs ) return;
3495 //if (isEnumValue() && !showEnumValues) return;
3496
3497 SrcLangExt lang = getLanguage();
3498 //printf("member=%s lang=%d\n",qPrint(name()),lang);
3499 bool optVhdl = lang==SrcLangExt::VHDL;
3500 QCString sep = getLanguageSpecificSeparator(lang,TRUE);
3501
3502 QCString scopeName = scName;
3503 QCString memAnchor = anchor();
3504 QCString ciname = container->displayName();
3505 const Definition *scopedContainer = container; // see bug 753608
3506 if (container->definitionType()==TypeGroup)
3507 {
3508 if (getClassDef()) { scopeName=getClassDef()->displayName(); scopedContainer=getClassDef(); }
3509 else if (getNamespaceDef()) { scopeName=getNamespaceDef()->displayName(); scopedContainer=getNamespaceDef(); }
3510 else if (getFileDef()) { scopeName=getFileDef()->displayName(); scopedContainer=getFileDef(); }
3511 ciname = (toGroupDef(container))->groupTitle();
3512 }
3513 else if (container->definitionType()==TypeFile && getNamespaceDef() && getNamespaceDef()->isLinkable())
3514 { // member is in a namespace, but is written as part of the file documentation
3515 // as well, so we need to make sure its anchor is unique (it is not really used).
3516 memAnchor.prepend("file_");
3517 }
3518
3519 QCString cname = container->name();
3520 QCString cfname = getOutputFileBase();
3521
3522 // get member name
3523 QCString doxyName=name();
3524 // prepend scope if there is any. TODO: make this optional for C only docs
3525 if (!scopeName.isEmpty())
3526 {
3527 doxyName.prepend(scopeName+sep);
3528 }
3529 QCString doxyArgs=argsString();
3530
3531 QCString ldef = definition();
3532 QCString title = name();
3533 //printf("member '%s' def='%s'\n",qPrint(name()),qPrint(ldef));
3534 if (isEnumerate())
3535 {
3536 if (title.at(0)=='@')
3537 {
3538 ldef = title = "anonymous enum";
3539 if (!m_enumBaseType.isEmpty())
3540 {
3541 ldef+=" : "+m_enumBaseType;
3542 }
3543 }
3544 else
3545 {
3546 if (lang==SrcLangExt::Cpp)
3547 {
3548 if (isEnumStruct()) ldef.prepend("struct ");
3549 else if (isStrong()) ldef.prepend("class ");
3550 }
3551 ldef.prepend("enum ");
3552 if (isSliceLocal())
3553 {
3554 ldef.prepend("local ");
3555 }
3556 }
3557 }
3558 else if (isEnumValue())
3559 {
3560 if (ldef.at(0)=='@')
3561 {
3562 ldef=ldef.mid(2);
3563 }
3564 }
3565 else if (isFunction() && !isObjCMethod())
3566 {
3567 title += "()";
3568 }
3569 if (lang == SrcLangExt::Slice)
3570 {
3571 // Remove the container scope from the member name.
3572 QCString prefix = scName + sep;
3573 int pos = ldef.findRev(prefix.data());
3574 if(pos != -1)
3575 {
3576 ldef.remove(pos, prefix.length());
3577 }
3578 }
3579 ldef.stripPrefix("constexpr ");
3580 ldef.stripPrefix("consteval ");
3581 ldef.stripPrefix("constinit ");
3582 ldef.stripPrefix("static ");
3583
3584 //----------------------------------------
3585
3586 ol.pushGeneratorState();
3587
3588 bool htmlEndLabelTable=FALSE;
3589 StringVector sl = getLabels(scopedContainer);
3590
3591 static const reg::Ex r(R"(@\d+)");
3592 reg::Match match;
3593 std::string sdef = ldef.str();
3594 LinkifyTextOptions options;
3595 options.setScope(scopedContainer).setFileScope(getBodyDef()).setSelf(this);
3596 if ((isVariable() || isTypedef()) && reg::search(sdef,match,r))
3597 {
3598 // find enum type and insert it in the definition
3599 bool found=false;
3600 for (const auto &vmd : *ml)
3601 {
3602 if (vmd->isEnumerate() && match.str()==vmd->name())
3603 {
3604 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3605 ol.startMemberDoc(ciname,name(),memAnchor,name(),memCount,memTotal,showInline);
3606 ol.addLabel(cfname, memAnchor);
3607 QCString prefix = match.prefix().str();
3608 QCString suffix = match.suffix().str();
3609 linkifyText(TextGeneratorOLImpl(ol),prefix,options);
3610 vmd->writeEnumDeclaration(ol,getClassDef(),getNamespaceDef(),getFileDef(),getGroupDef(),getModuleDef());
3611 linkifyText(TextGeneratorOLImpl(ol),suffix,options);
3612
3613 found=true;
3614 break;
3615 }
3616 }
3617 if (!found) // anonymous compound
3618 {
3619 ClassDef *annoClassDef=getClassDefOfAnonymousType();
3620 QCString typeName;
3621 if (annoClassDef) typeName=annoClassDef->compoundTypeString();
3622 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3623 ol.startMemberDoc(ciname,name(),memAnchor,"["+typeName+"]",memCount,memTotal,showInline);
3624 ol.addLabel(cfname, memAnchor);
3625 // search for the last anonymous compound name in the definition
3626
3627 ol.startMemberDocName(isObjCMethod());
3628 if (reg::search(sdef,match,reAnonymous))
3629 {
3630 QCString prefix = match.prefix().str();
3631 QCString suffix = match.suffix().str();
3632 ol.docify(prefix);
3633 ol.docify(" { ... } ");
3634 linkifyText(TextGeneratorOLImpl(ol),removeAnonymousScopes(suffix),options);
3635 }
3636 else
3637 {
3638 linkifyText(TextGeneratorOLImpl(ol),ldef,options);
3639 }
3640 }
3641 }
3642 else // not an enum value or anonymous compound
3643 {
3644 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3645 ol.startMemberDoc(ciname,name(),memAnchor,title,memCount,memTotal,showInline);
3646 ol.addLabel(cfname, memAnchor);
3647
3648 if (!m_metaData.isEmpty() && getLanguage()==SrcLangExt::Slice)
3649 {
3650 ol.startMemberDocPrefixItem();
3651 ol.docify(m_metaData);
3652 ol.endMemberDocPrefixItem();
3653 }
3654
3655 const ClassDef *cd=getClassDef();
3656 const NamespaceDef *nd=getNamespaceDef();
3657 if (!m_defTmpArgLists.empty() && lang==SrcLangExt::Cpp)
3658 // definition has explicit template parameter declarations
3659 {
3660 for (const ArgumentList &tal : m_defTmpArgLists)
3661 {
3662 if (!tal.empty())
3663 {
3664 ol.startMemberDocPrefixItem();
3665 _writeTemplatePrefix(ol,scopedContainer,tal);
3666 ol.endMemberDocPrefixItem();
3667 }
3668 }
3669 }
3670 else // definition gets it template parameters from its class
3671 // (since no definition was found)
3672 {
3673 if (cd && lang==SrcLangExt::Cpp && !isTemplateSpecialization())
3674 {
3675 for (const ArgumentList &tal : cd->getTemplateParameterLists())
3676 {
3677 if (!tal.empty())
3678 {
3679 ol.startMemberDocPrefixItem();
3680 _writeTemplatePrefix(ol,scopedContainer,tal,false);
3681 ol.endMemberDocPrefixItem();
3682 }
3683 }
3684 }
3685 if (m_tArgList.hasParameters() && lang==SrcLangExt::Cpp) // function template prefix
3686 {
3687 ol.startMemberDocPrefixItem();
3688 _writeTemplatePrefix(ol,scopedContainer,m_tArgList);
3689 ol.endMemberDocPrefixItem();
3690 }
3691 }
3692
3693 if (!sl.empty())
3694 {
3695 ol.pushGeneratorState();
3696 ol.disableAll();
3697 ol.enable(OutputType::Html);
3698 ol.writeString("<table class=\"mlabels\">\n");
3699 ol.writeString(" <tr>\n");
3700 ol.writeString(" <td class=\"mlabels-left\">\n");
3701 ol.popGeneratorState();
3702 htmlEndLabelTable=TRUE;
3703 }
3704
3705 ol.startMemberDocName(isObjCMethod());
3706 if (cd && cd->isObjectiveC())
3707 {
3708 // strip scope name
3709 int ep = ldef.find("::");
3710 if (ep!=-1)
3711 {
3712 int sp=ldef.findRev(' ',ep);
3713 if (sp!=-1)
3714 {
3715 ldef=ldef.left(sp+1)+ldef.mid(ep+2);
3716 } else {
3717 ldef=ldef.mid(ep+2);
3718 }
3719 }
3720 // strip keywords
3721 int dp = ldef.find(':');
3722 if (dp!=-1)
3723 {
3724 ldef=ldef.left(dp+1);
3725 }
3726 int dl=static_cast<int>(ldef.length());
3727 //printf("start >%s<\n",qPrint(ldef));
3728 int i=dl-1;
3729 while (i>=0 && (isId(ldef.at(i)) || ldef.at(i)==':')) i--;
3730 while (i>=0 && isspace(static_cast<uint8_t>(ldef.at(i)))) i--;
3731 if (i>0)
3732 {
3733 // insert branches around the type
3734 ldef="("+ldef.left(i+1)+")"+ldef.mid(i+1);
3735 }
3736 //printf("end >%s< i=%d\n",qPrint(ldef),i);
3737 if (isStatic()) ldef.prepend("+ "); else ldef.prepend("- ");
3738 }
3739
3740 if (optVhdl)
3741 {
3742 hasParameterList=VhdlDocGen::writeVHDLTypeDocumentation(this,scopedContainer,ol);
3743 }
3744 else if (lang==SrcLangExt::Slice)
3745 {
3746 // Eliminate the self-reference.
3747 int pos = ldef.findRev(' ');
3748 if (pos<0) pos=0;
3749 if (pos>0)
3750 {
3751 linkifyText(TextGeneratorOLImpl(ol),ldef.left(pos),options);
3752 }
3753 ol.docify(ldef.mid(pos));
3754 const Definition *scope = cd;
3755 if (scope==nullptr) scope = nd;
3756 hasParameterList=writeDefArgumentList(ol,scope,this);
3757 }
3758 else
3759 {
3760 linkifyText(TextGeneratorOLImpl(ol),substitute(ldef,"::",sep),options);
3761 const Definition *scope = cd;
3762 if (scope==nullptr) scope = nd;
3763 hasParameterList=writeDefArgumentList(ol,scope,this);
3764 }
3765
3766 if (hasOneLineInitializer()) // add initializer
3767 {
3768 if (isTypeAlias())
3769 {
3770 ol.docify(" = ");
3771 QCString init = m_initializer.simplifyWhiteSpace();
3772 linkifyText(TextGeneratorOLImpl(ol),init,options);
3773 }
3774 else if (!isDefine())
3775 {
3776 ol.docify(" ");
3777 QCString init = m_initializer.simplifyWhiteSpace();
3778 linkifyText(TextGeneratorOLImpl(ol),init,options);
3779 }
3780 else
3781 {
3782 ol.writeNonBreakableSpace(3);
3783 linkifyText(TextGeneratorOLImpl(ol),m_initializer,options);
3784 }
3785 }
3786 if (!excpString().isEmpty()) // add exception list
3787 {
3788 writeExceptionList(ol,cd,this);
3789 hasParameterList=true; // call endParameterList below
3790 }
3791 }
3792
3793 ol.pushGeneratorState();
3794 ol.disable(OutputType::Html);
3795 if (!sl.empty())
3796 {
3797 ol.startLabels();
3798 size_t count=0;
3799 for (const auto &s : sl)
3800 {
3801 count++;
3802 ol.writeLabel(s,count==sl.size());
3803 }
3804 ol.endLabels();
3805 }
3806 ol.popGeneratorState();
3807
3808 if (hasParameterList)
3809 {
3810 ol.endParameterList();
3811 ol.endMemberDoc(TRUE);
3812 }
3813 else
3814 {
3815 ol.endMemberDocName();
3816 ol.endMemberDoc(FALSE);
3817 }
3818
3819 // for HTML write the labels here
3820 ol.pushGeneratorState();
3821 ol.disableAll();
3822 ol.enable(OutputType::Html);
3823 if (htmlEndLabelTable)
3824 {
3825 ol.writeString(" </td>\n");
3826 ol.writeString(" <td class=\"mlabels-right\">\n");
3827 ol.startLabels();
3828 size_t count=0;
3829 for (const auto &s : sl)
3830 {
3831 count++;
3832 ol.writeLabel(s,count==sl.size());
3833 }
3834 ol.endLabels();
3835 ol.writeString(" </td>\n");
3836 ol.writeString(" </tr>\n");
3837 ol.writeString("</table>\n");
3838 }
3839 ol.writeString("</div>");
3840 ol.popGeneratorState();
3841
3842
3843 ol.endDoxyAnchor(cfname,memAnchor);
3844 ol.startIndent();
3845
3846 _writeGroupInclude(ol,inGroup);
3847
3848 /* write multi-line initializer (if any) */
3849 if (hasMultiLineInitializer()) _writeMultiLineInitializer(ol,scopeName);
3850
3851 /* write brief description */
3852 QCString brief = briefDescription();
3853 if (!brief.isEmpty() &&
3854 (Config_getBool(REPEAT_BRIEF) ||
3855 !Config_getBool(BRIEF_MEMBER_DESC)
3856 )
3857 )
3858 {
3859 ol.startParagraph();
3860 ol.generateDoc(briefFile(),
3861 briefLine(),
3862 scopedContainer,
3863 this,
3864 brief,
3865 DocOptions()
3866 .setSingleLine(true));
3867 ol.endParagraph();
3868 }
3869
3870 /* write detailed description */
3871 QCString detailed = documentation();
3872 if (!detailed.isEmpty() ||
3873 !inbodyDocumentation().isEmpty())
3874 {
3875 // write vhdl inline code with or without option INLINE_SOURCE
3876 if (optVhdl && VhdlDocGen::isMisc(this))
3877 {
3878 VhdlDocGen::writeSource(this,ol,cname);
3879 return;
3880 }
3881 else
3882 {
3883 ol.generateDoc(docFile(),
3884 docLine(),
3885 scopedContainer,
3886 this,
3887 detailed+"\n",
3888 DocOptions()
3889 .setIndexWords(true));
3890 }
3891
3892 if (!inbodyDocumentation().isEmpty())
3893 {
3894 ol.generateDoc(inbodyFile(),
3895 inbodyLine(),
3896 scopedContainer,
3897 this,
3898 inbodyDocumentation()+"\n",
3899 DocOptions()
3900 .setIndexWords(true));
3901 }
3902 }
3903 else if (!brief.isEmpty() && (Config_getBool(REPEAT_BRIEF) || !Config_getBool(BRIEF_MEMBER_DESC)))
3904 {
3905 if (!inbodyDocumentation().isEmpty())
3906 {
3907 ol.generateDoc(inbodyFile(),
3908 inbodyLine(),
3909 scopedContainer,
3910 this,
3911 inbodyDocumentation()+"\n",
3912 DocOptions()
3913 .setIndexWords(true));
3914 }
3915 }
3916
3917
3918 //printf("***** defArgList=%p name=%s docs=%s hasDocs=%d\n",
3919 // defArgList,
3920 // defArgList?defArgList->hasDocumentation():-1);
3921 const ArgumentList &docArgList = m_templateMaster ?
3922 m_templateMaster->argumentList() :
3923 m_defArgList;
3924 ol.generateDoc(docFile(),
3925 docLine(),
3926 scopedContainer,
3927 this, // memberDef
3928 inlineArgListToDoc(docArgList), // docStr
3929 DocOptions()
3930 .setIndexWords(true));
3931
3932 const ArgumentList &docTemplateArgList = m_templateMaster ?
3933 m_templateMaster->templateArguments() :
3934 m_tArgList;
3935 ol.generateDoc(docFile(),
3936 docLine(),
3937 scopedContainer,
3938 this, // memberDef
3939 inlineTemplateArgListToDoc(docTemplateArgList), // docStr
3940 DocOptions()
3941 .setIndexWords(true));
3942
3943 _writeEnumValues(ol,scopedContainer,cfname,ciname,cname);
3944 _writeReimplements(ol);
3945 _writeReimplementedBy(ol);
3946 _writeCategoryRelation(ol);
3947 _writeExamples(ol);
3948 _writeTypeConstraints(ol);
3949 QCString scopeStr = getScopeString();
3950 writeSourceDef(ol);
3951 writeInlineCode(ol,scopeStr);
3952 if (hasReferencesRelation()) writeSourceRefs(ol,scopeStr);
3953 if (hasReferencedByRelation()) writeSourceReffedBy(ol,scopeStr);
3954 _writeCallGraph(ol);
3955 _writeCallerGraph(ol);
3956 if (hasRequirementRefs()) writeRequirementRefs(ol);
3957
3958 ol.endIndent();
3959
3960 // enable LaTeX again
3961 //if (Config_getBool(EXTRACT_ALL) && !hasDocs) ol.enable(OutputType::Latex);
3962 ol.popGeneratorState();
3963
3964 warnIfUndocumentedParams();
3965}
3966
3967// strip scope and field name from the type
3968// example: "struct N<K::J>::S.v.c" will become "struct v"
3969static QCString simplifyTypeForTable(const QCString &s)
3970{
3971 QCString ts=removeAnonymousScopes(s);
3972 if (ts.endsWith("::")) ts = ts.left(ts.length()-2);
3973 static const reg::Ex re1(R"(\a\w*::)"); // non-template version
3974 static const reg::Ex re2(R"(\a\w*<[^>]*>::)"); // template version
3975 reg::Match match;
3976 std::string t = ts.str();
3977 while (reg::search(t,match,re2) || reg::search(t,match,re1))
3978 {
3979 t = match.prefix().str() + match.suffix().str(); // remove the matched part
3980 }
3981 //printf("simplifyTypeForTable(%s)->%s\n",qPrint(s),qPrint(t));
3982 return t;
3983}
3984
3985QCString MemberDefImpl::fieldType() const
3986{
3987 QCString type = m_accessorType;
3988 if (type.isEmpty())
3989 {
3990 type = m_type;
3991 }
3992
3993 if (isTypedef() && getLanguage() != SrcLangExt::Slice) type.prepend("typedef ");
3994 return simplifyTypeForTable(type);
3995}
3996
3997void MemberDefImpl::writeMemberDocSimple(OutputList &ol, const Definition *container) const
3998{
3999 Definition *scope = getOuterScope();
4000 QCString doxyName = name();
4001 QCString doxyArgs = argsString();
4002 QCString memAnchor = anchor();
4003 QCString cfname = getOutputFileBase();
4004 QCString cname;
4005 if (scope) cname = scope->name();
4006 if (doxyName.at(0)=='@')
4007 {
4008 doxyName="__unnamed__";
4009 }
4010
4011 ClassDef *cd = m_accessorClass;
4012 //printf("===> %s::anonymous: %s\n",qPrint(name()),cd?qPrint(cd->name()):"<none>");
4013
4014 LinkifyTextOptions options;
4015 options.setScope(scope).setFileScope(getBodyDef()).setSelf(this);
4016
4017 if (container && container->definitionType()==Definition::TypeClass &&
4018 !(toClassDef(container))->isJavaEnum())
4019 {
4020 ol.startInlineMemberType();
4021 ol.startDoxyAnchor(cfname,cname,memAnchor,doxyName,doxyArgs);
4022 ol.addLabel(cfname,memAnchor);
4023
4024 QCString ts = fieldType();
4025
4026 if (isFunctionPtr())
4027 ts = m_type + m_args;
4028
4029 if (cd) // cd points to an anonymous struct pointed to by this member
4030 // so we add a link to it from the type column.
4031 {
4032 int i=0;
4033 const char *prefixes[] = { "struct ","union ","class ", nullptr };
4034 const char **p = prefixes;
4035 while (*p)
4036 {
4037 int l=qstrlen(*p);
4038 if (ts.left(l)==*p)
4039 {
4040 ol.writeString(*p);
4041 i=l;
4042 }
4043 p++;
4044 }
4045 ol.writeObjectLink(cd->getReference(),
4046 cd->getOutputFileBase(),
4047 cd->anchor(),ts.mid(i));
4048 }
4049 else // use standard auto linking
4050 {
4051 linkifyText(TextGeneratorOLImpl(ol),ts,options);
4052 }
4053 ol.endDoxyAnchor(cfname,memAnchor);
4054 ol.endInlineMemberType();
4055 }
4056
4057 ol.startInlineMemberName();
4058 ol.docify(doxyName);
4059 if (isVariable() && !argsString().isEmpty() && !isObjCMethod() && !isFunctionPtr())
4060 {
4061 linkifyText(TextGeneratorOLImpl(ol),argsString(),LinkifyTextOptions(options).setArgumentList(&m_defArgList));
4062 }
4063 if (!m_bitfields.isEmpty()) // add bitfields
4064 {
4065 linkifyText(TextGeneratorOLImpl(ol),m_bitfields,options);
4066 }
4067 if (hasOneLineInitializer() && !isDefine())
4068 {
4069 ol.writeString(" ");
4070 linkifyText(TextGeneratorOLImpl(ol),m_initializer.simplifyWhiteSpace(),options);
4071 }
4072 ol.endInlineMemberName();
4073
4074 ol.startInlineMemberDoc();
4075
4076 QCString brief = briefDescription();
4077 QCString detailed = documentation();
4078
4079 /* write brief description */
4080 if (!brief.isEmpty())
4081 {
4082 ol.generateDoc(briefFile(),
4083 briefLine(),
4084 getOuterScope()?getOuterScope():container,this,
4085 brief,
4086 DocOptions()
4087 .setSingleLine(true));
4088 }
4089
4090 /* write detailed description */
4091 if (!detailed.isEmpty())
4092 {
4093 if (!brief.isEmpty())
4094 {
4095 ol.disable(OutputType::Html);
4096 ol.lineBreak();
4097 ol.enable(OutputType::Html);
4098 }
4099 ol.generateDoc(docFile(),
4100 docLine(),
4101 getOuterScope()?getOuterScope():container,this,
4102 detailed+"\n",
4103 DocOptions());
4104 }
4105
4106 ol.endInlineMemberDoc();
4107}
4108
4109QCString MemberDefImpl::memberTypeName() const
4110{
4111 if (m_mtype == MemberType::Define)
4112 {
4113 return "macro definition";
4114 }
4115 else if (m_mtype == MemberType::Enumeration)
4116 {
4117 return "enumeration";
4118 }
4119 return to_string_lower(m_mtype);
4120}
4121
4122void MemberDefImpl::warnIfUndocumented() const
4123{
4124 /*
4125 * Removed bug_303020:
4126 * if (m_memberGroup) return;
4127 */
4128 const ClassDef *cd = getClassDef();
4129 const NamespaceDef *nd = getNamespaceDef();
4130 const FileDef *fd = getFileDef();
4131 const GroupDef *gd = getGroupDef();
4132 const Definition *d=nullptr;
4133 QCString t;
4134 if (cd)
4135 {
4136 t=cd->compoundTypeString();
4137 d=cd;
4138 }
4139 else if (nd)
4140 {
4141 t=nd->compoundTypeString();
4142 d=nd;
4143 }
4144 else if (gd)
4145 {
4146 t="group";
4147 d=gd;
4148 }
4149 else
4150 {
4151 t="file";
4152 d=fd;
4153 }
4154 bool extractAll = Config_getBool(EXTRACT_ALL);
4155
4156 //printf("%s:warnIfUndoc: hasUserDocs=%d isFriendClass=%d protection=%d isRef=%d isDel=%d\n",
4157 // qPrint(name()),
4158 // hasUserDocumentation(),isFriendClass(),protectionLevelVisible(m_prot),isReference(),isDeleted());
4159 if ((!hasUserDocumentation() && !extractAll) &&
4160 !isFriendClass() &&
4161 name().find('@')==-1 && d && d->name().find('@')==-1 &&
4162 !_isAnonymousBitField() &&
4163 protectionLevelVisible(m_prot) &&
4164 !isReference() && !isDeleted()
4165 )
4166 {
4167 SrcLangExt lang = getLanguage();
4168 QCString sep = getLanguageSpecificSeparator(lang,TRUE);
4169 warn_undoc(getDefFileName(),getDefLine(),"Member {}{} ({}) of {} {} is not documented.",
4170 name(),argsString(),memberTypeName(),t,
4171 substitute(d->name(),"::",sep));
4172 }
4173 else if (!hasDetailedDescription())
4174 {
4175 warnIfUndocumentedParams();
4176 }
4177
4178 // if it is an enum, we check that its members are documented
4179 if (!extractAll && isEnumerate() && Config_getBool(WARN_IF_UNDOC_ENUM_VAL))
4180 {
4181 for (const auto &fmd : enumFieldList())
4182 {
4183 if (!fmd->isLinkableInProject())
4184 {
4185 SrcLangExt lang = getLanguage();
4186 QCString sep = getLanguageSpecificSeparator(lang,TRUE);
4187 warn(fmd->getDefFileName(),fmd->getDefLine(), "Documentation for enum member '{}{}{}' is missing.",
4188 qualifiedName(),sep,fmd->name());
4189 }
4190 }
4191 }
4192}
4193
4194bool MemberDefImpl::visibleInIndex() const
4195{
4196 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
4197 bool extractStatic = Config_getBool(EXTRACT_STATIC);
4198 return (!isAnonymous() &&
4199 (!hideUndocMembers || hasDocumentation()) &&
4200 (!isStatic() || extractStatic) &&
4201 isLinkable()
4202 );
4203}
4204
4205static QCString stripTrailingReturn(const QCString &trailRet)
4206{
4207 QCString ret = trailRet;
4208
4209 ret = ret.stripWhiteSpace();
4210 if (ret.startsWith("->"))
4211 {
4212 ret = ret.mid(2).stripWhiteSpace();
4213 return ret;
4214 }
4215 return trailRet;
4216}
4217
4218static std::mutex g_detectUndocumentedParamsMutex;
4219
4220void MemberDefImpl::detectUndocumentedParams(bool hasParamCommand,bool hasReturnCommand) const
4221{
4222 //printf("%s:detectUndocumentedParams(%d,%d)\n",qPrint(name()),hasParamCommand,hasReturnCommand);
4223 bool isPython = getLanguage()==SrcLangExt::Python;
4224
4225 // this function is called while parsing the documentation. A member can have multiple
4226 // documentation blocks, which could be handled by multiple threads, hence this guard.
4227 std::lock_guard<std::mutex> lock(g_detectUndocumentedParamsMutex);
4228
4229 if (!m_hasDocumentedParams && hasParamCommand)
4230 {
4231 //printf("%s:hasDocumentedParams=TRUE;\n",qPrint(name()));
4232 m_hasDocumentedParams = true;
4233 }
4234 else if (!m_hasDocumentedParams)
4235 {
4236 const ArgumentList &al = argumentList();
4237 const ArgumentList &declAl = declArgumentList();
4238 bool allDoc=TRUE; // no parameter => all parameters are documented
4239 if ( // member has parameters
4240 al.hasParameters() // with at least one parameter (that is not void)
4241 )
4242 {
4243 // see if all parameters have documentation
4244 for (auto it = al.begin(); it!=al.end() && allDoc; ++it)
4245 {
4246 const Argument &a = *it;
4247 if (!a.name.isEmpty() && a.type!="void" && a.name!="..." &&
4248 !(isPython && (a.name=="self" || a.name=="cls"))
4249 )
4250 {
4251 allDoc = !a.docs.isEmpty();
4252 }
4253 //printf("a.type=%s a.name=%s doc=%s\n",
4254 // qPrint(a.type),qPrint(a.name),qPrint(a.docs));
4255 }
4256 if (!allDoc && declAl.empty()) // try declaration arguments as well
4257 {
4258 allDoc=true;
4259 for (auto it = al.begin(); it!=al.end() && allDoc; ++it)
4260 {
4261 const Argument &a = *it;
4262 if (!a.name.isEmpty() && a.type!="void" && a.name!="..." &&
4263 !(isPython && (a.name=="self" || a.name=="cls"))
4264 )
4265 {
4266 allDoc = !a.docs.isEmpty();
4267 }
4268 //printf("a.name=%s doc=%s\n",qPrint(a.name),qPrint(a.docs));
4269 }
4270 }
4271 }
4272 if (allDoc)
4273 {
4274 //printf("%s:hasDocumentedParams=TRUE;\n",qPrint(name()));
4275 m_hasDocumentedParams = true;
4276 }
4277 }
4278
4279 //printf("Member %s hasDocumentedReturnType=%d hasReturnCommand=%d\n",
4280 // qPrint(name()),m_hasDocumentedReturnType,hasReturnCommand);
4281 m_hasDocumentedReturnType = m_hasDocumentedReturnType || hasReturnCommand;
4282}
4283
4284void MemberDefImpl::warnIfUndocumentedParams() const
4285{
4286 QCString returnType = typeString();
4287 bool isFortran = getLanguage()==SrcLangExt::Fortran;
4288 bool isFortranSubroutine = isFortran && returnType.find("subroutine")!=-1;
4289
4290 bool isVoidReturn = returnType=="void" || returnType.endsWith(" void");
4291 if (!isVoidReturn && (returnType=="auto" || returnType.endsWith(" auto")))
4292 {
4293 const ArgumentList &defArgList=isDocsForDefinition() ? argumentList() : declArgumentList();
4294 if (!defArgList.trailingReturnType().isEmpty())
4295 {
4296 QCString strippedTrailingReturn = stripTrailingReturn(defArgList.trailingReturnType());
4297 isVoidReturn = (strippedTrailingReturn=="void") || (strippedTrailingReturn.endsWith(" void"));
4298 }
4299 }
4300 if (!Config_getBool(EXTRACT_ALL) &&
4301 Config_getBool(WARN_IF_UNDOCUMENTED) &&
4302 Config_getBool(WARN_NO_PARAMDOC) &&
4303 isFunction() &&
4304 !isDeleted() &&
4305 !isReference() &&
4306 !Doxygen::suppressDocWarnings)
4307 {
4308 if (!m_hasDocumentedParams)
4309 {
4310 warn_doc_error(docFile(),docLine(),
4311 "parameters of member {} are not documented",
4312 qualifiedName());
4313 }
4314 if (!m_hasDocumentedReturnType &&
4315 hasDocumentation() && !returnType.isEmpty() &&
4316 !( // not one of the cases where nothing is returned
4317 isVoidReturn || // void return type
4318 isFortranSubroutine || // fortran subroutine
4319 isConstructor() || // a constructor
4320 isDestructor() || // or a destructor
4321 isFriend() // or a friend
4322 )
4323 )
4324 {
4325 warn_doc_error(docFile(),docLine(),
4326 "return type of member {} is not documented",
4327 qualifiedName());
4328 }
4329 }
4330 if (Config_getBool(WARN_IF_DOC_ERROR) &&
4331 m_hasDocumentedReturnType &&
4332 (isVoidReturn || // void return type
4333 isFortranSubroutine || // fortran subroutine
4334 isConstructor() || // a constructor
4335 isDestructor())) // or destructor
4336 {
4337 warn_doc_error(docFile(),docLine(),"found documented return type for {} that does not return anything",
4338 qualifiedName());
4339 }
4340}
4341
4342bool MemberDefImpl::isDocumentedFriendClass() const
4343{
4344 ClassDef *fcd=nullptr;
4345 QCString baseName=name();
4346 int i=baseName.find('<');
4347 if (i!=-1) baseName=baseName.left(i);
4348 return (isFriendClass() &&
4349 (fcd=getClass(baseName)) && fcd->isLinkable());
4350}
4351
4352bool MemberDefImpl::isDeleted() const
4353{
4354 return m_defArgList.isDeleted();
4355}
4356
4357bool MemberDefImpl::hasDocumentation() const
4358{
4359 return DefinitionMixin::hasDocumentation() ||
4360 (m_mtype==MemberType::Enumeration && m_docEnumValues) || // has enum values
4361 (m_defArgList.hasDocumentation()|| m_tArgList.hasTemplateDocumentation()); // has doc (template) arguments
4362}
4363
4364
4369
4370QCString MemberDefImpl::getScopeString() const
4371{
4372 QCString result;
4373 if (isStrong()) result=name();
4374 else if (getClassDef()) result=getClassDef()->displayName();
4375 else if (getNamespaceDef()) result=getNamespaceDef()->displayName();
4376 return result;
4377}
4378
4379void MemberDefImpl::setAnchor()
4380{
4381 QCString memAnchor = name();
4382 if (!m_args.isEmpty()) memAnchor+=m_args;
4383 if (m_memSpec.isAlias()) // this is for backward compatibility
4384 {
4385 memAnchor.prepend(" = "+m_initializer);
4386 }
4387 memAnchor.prepend(definition()); // actually the method name is now included
4388 // twice, which is silly, but we keep it this way for backward
4389 // compatibility.
4390
4391 // include number of template arguments as well,
4392 // to distinguish between two template
4393 // specializations that only differ in the template parameters.
4394 if (m_tArgList.hasParameters())
4395 {
4396 char buf[20];
4397 qsnprintf(buf,20,"%d:",static_cast<int>(m_tArgList.size()));
4398 buf[19]='\0';
4399 memAnchor.prepend(buf);
4400 }
4401 if (!m_requiresClause.isEmpty())
4402 {
4403 memAnchor+=" "+m_requiresClause;
4404 }
4405 if (m_redefineCount>0)
4406 {
4407 char buf[20];
4408 qsnprintf(buf,20,":%d",m_redefineCount);
4409 buf[19]='\0';
4410 memAnchor.append(buf);
4411 }
4412
4413 // convert to md5 hash
4414 uint8_t md5_sig[16];
4415 char sigStr[33];
4416 MD5Buffer(memAnchor.data(),static_cast<unsigned int>(memAnchor.length()),md5_sig);
4417 MD5SigToString(md5_sig,sigStr);
4418 m_anc = QCString("a")+sigStr;
4419}
4420
4421void MemberDefImpl::setGroupDef(GroupDef *gd,Grouping::GroupPri_t pri,
4422 const QCString &fileName,int startLine,
4423 bool hasDocs,MemberDef *member)
4424{
4425 //printf("%s MemberDefImpl::setGroupDef(%s)\n",qPrint(name()),qPrint(gd->name()));
4426 m_group=gd;
4427 m_grouppri=pri;
4428 m_groupFileName=fileName;
4429 m_groupStartLine=startLine;
4430 m_groupHasDocs=hasDocs;
4431 m_groupMember=member;
4432 m_isLinkableCached = 0;
4433}
4434
4449
4457
4458void MemberDefImpl::setNamespace(NamespaceDef *nd)
4459{
4460 m_nspace=nd;
4461 setOuterScope(nd);
4462}
4463
4464std::unique_ptr<MemberDef> MemberDefImpl::createTemplateInstanceMember(
4465 const ArgumentList &formalArgs,const std::unique_ptr<ArgumentList> &actualArgs) const
4466{
4467 //printf(" Member %s %s %s\n",qPrint(typeString()),qPrint(name()),qPrint(argsString()));
4468 std::unique_ptr<ArgumentList> actualArgList = std::make_unique<ArgumentList>(m_defArgList);
4469 if (!m_defArgList.empty())
4470 {
4471 // replace formal arguments with actuals
4472 for (Argument &arg : *actualArgList)
4473 {
4474 arg.type = substituteTemplateArgumentsInString(arg.type,formalArgs,actualArgs.get());
4475 }
4476 actualArgList->setTrailingReturnType(
4477 substituteTemplateArgumentsInString(actualArgList->trailingReturnType(),formalArgs,actualArgs.get()));
4478 }
4479
4480 QCString methodName=name();
4481 if (methodName.startsWith("operator ")) // conversion operator
4482 {
4483 methodName=substituteTemplateArgumentsInString(methodName,formalArgs,actualArgs.get());
4484 }
4485
4486 auto imd = createMemberDef(
4487 getDefFileName(),getDefLine(),getDefColumn(),
4488 substituteTemplateArgumentsInString(m_type,formalArgs,actualArgs.get()),
4489 methodName,
4490 substituteTemplateArgumentsInString(m_args,formalArgs,actualArgs.get()),
4491 m_exception, m_prot,
4492 m_virt, m_stat, m_related, m_mtype,
4493 ArgumentList(), ArgumentList(), ""
4494 );
4495 auto mmd = toMemberDefMutable(imd.get());
4496 mmd->moveArgumentList(std::move(actualArgList));
4497 mmd->setDefinition(substituteTemplateArgumentsInString(m_def,formalArgs,actualArgs.get()));
4498 mmd->setBodyDef(getBodyDef());
4499 mmd->setBodySegment(getDefLine(),getStartBodyLine(),getEndBodyLine());
4500 mmd->setFormalTemplateArguments(formalArgs);
4501
4502 // TODO: init other member variables (if needed).
4503 // TODO: reimplemented info
4504 return imd;
4505}
4506
4507bool MemberDefImpl::hasOneLineInitializer() const
4508{
4509 //printf("%s: init=%s, initLines=%d maxInitLines=%d userInitLines=%d\n",
4510 // qPrint(name()),qPrint(m_initializer),m_initLines,
4511 // m_maxInitLines,m_userInitLines);
4512 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4513 return !m_initializer.isEmpty() && m_initLines==0 && // one line initializer
4514 !isFuncLikeMacro &&
4515 ((m_maxInitLines>0 && m_userInitLines==-1) || m_userInitLines>0); // enabled by default or explicitly
4516}
4517
4518bool MemberDefImpl::hasMultiLineInitializer() const
4519{
4520 //printf("initLines=%d userInitLines=%d maxInitLines=%d\n",
4521 // initLines,userInitLines,maxInitLines);
4522 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4523 return (m_initLines>0 || (!m_initializer.isEmpty() && isFuncLikeMacro)) &&
4524 ((m_initLines<m_maxInitLines && m_userInitLines==-1) // implicitly enabled
4525 || m_initLines<m_userInitLines // explicitly enabled
4526 );
4527}
4528
4529void MemberDefImpl::setInitializer(const QCString &initializer)
4530{
4531 size_t indent=0;
4532 m_initializer=detab(initializer,indent);
4533 int l=static_cast<int>(m_initializer.length());
4534 int p=l-1;
4535 while (p>=0 && isspace(static_cast<uint8_t>(m_initializer.at(p)))) p--;
4536 m_initializer=m_initializer.left(p+1);
4537 m_initLines=m_initializer.contains('\n');
4538 stripIndentationVerbatim(m_initializer,indent, false);
4539
4540 //printf("%s::setInitializer(%s)\n",qPrint(name()),qPrint(m_initializer));
4541}
4542
4543void MemberDefImpl::addListReference(const Definition *)
4544{
4545 bool optimizeOutputForC = Config_getBool(OPTIMIZE_OUTPUT_FOR_C);
4546 SrcLangExt lang = getLanguage();
4547 if (!isLinkableInProject()) return;
4548 QCString memLabel;
4549 if (optimizeOutputForC)
4550 {
4551 memLabel=theTranslator->trGlobal(TRUE,TRUE);
4552 }
4553 else if (lang==SrcLangExt::Fortran)
4554 {
4555 memLabel=theTranslator->trSubprogram(TRUE,TRUE);
4556 }
4557 else
4558 {
4559 memLabel=theTranslator->trMember(TRUE,TRUE);
4560 }
4561 QCString memName = name();
4562 Definition *pd=getOuterScope();
4563 QCString pdName = pd->definitionType()==Definition::TypeClass ?
4564 (toClassDef(pd))->displayName() : pd->name();
4565 QCString sep = getLanguageSpecificSeparator(lang,TRUE);
4566 QCString memArgs;
4567 if (!isRelated())
4568 {
4569 if (isObjCMethod())
4570 {
4571 memName = "[" + pd->name() + " " + name() + "]";
4572 }
4573 else
4574 {
4575 if (pd!=Doxygen::globalScope) memName.prepend(pdName+sep);
4576 memArgs = argsString();
4577 }
4578 }
4579 const RefItemVector &xrefItems = xrefListItems();
4580 if (sep!="::")
4581 {
4582 memName = substitute(memName,"::",sep);
4583 }
4584 addRefItem(xrefItems,
4585 qualifiedName()+argsString(), // argsString is needed for overloaded functions (see bug 609624)
4586 memLabel,
4587 getOutputFileBase()+"#"+anchor(),memName,memArgs,pd);
4588}
4589
4594
4595const MemberList *MemberDefImpl::getSectionList(const Definition *container) const
4596{
4597 auto it = m_sectionMap.find(container);
4598 return it!=m_sectionMap.end() ? it->second : nullptr;
4599}
4600
4601void MemberDefImpl::setSectionList(const Definition *container,const MemberList *sl)
4602{
4603 //printf("MemberDefImpl::setSectionList(%s,%p) name=%s\n",qPrint(d->name()),sl,qPrint(name()));
4604 m_sectionMap.emplace(container,sl);
4605}
4606
4607Specifier MemberDefImpl::virtualness(int count) const
4608{
4609 if (count>25)
4610 {
4611 warn(getDefFileName(),getDefLine(),
4612 "Internal inconsistency: recursion detected in overload relation for member {}!",name());
4613 return Specifier::Normal;
4614 }
4615 Specifier v = m_virt;
4616 const MemberDef *rmd = reimplements();
4617 while (rmd && v==Specifier::Normal)
4618 {
4619 v = rmd->virtualness(count+1)==Specifier::Normal ? Specifier::Normal : Specifier::Virtual;
4620 rmd = rmd->reimplements();
4621 }
4622 return v;
4623}
4624
4625void MemberDefImpl::writeTagFile(TextStream &tagFile,bool useQualifiedName,bool showNamespaceMembers) const
4626{
4627 if (!isLinkableInProject()) return;
4628 if (!showNamespaceMembers && getNamespaceDef()) return;
4629 tagFile << " <member kind=\"";
4630 if (m_mtype == MemberType::Enumeration)
4631 {
4632 tagFile << "enumeration";
4633 }
4634 else
4635 {
4636 tagFile << to_string_lower(m_mtype);
4637 }
4638 if (m_prot!=Protection::Public)
4639 {
4640 tagFile << "\" protection=\"";
4641 if (m_prot==Protection::Protected) tagFile << "protected";
4642 else if (m_prot==Protection::Package) tagFile << "package";
4643 else /* Private */ tagFile << "private";
4644 }
4645 if (m_virt!=Specifier::Normal)
4646 {
4647 tagFile << "\" virtualness=\"";
4648 if (m_virt==Specifier::Virtual) tagFile << "virtual";
4649 else /* Pure */ tagFile << "pure";
4650 }
4651 if (isStatic())
4652 {
4653 tagFile << "\" static=\"yes";
4654 }
4655 tagFile << "\">\n";
4656 if (typeString()!=QCString("@"))
4657 {
4658 tagFile << " <type>" << convertToXML(typeString()) << "</type>\n";
4659 }
4660 QCString fn = getOutputFileBase();
4661 addHtmlExtensionIfMissing(fn);
4662 tagFile << " <name>" << convertToXML(useQualifiedName ? qualifiedName() : name()) << "</name>\n";
4663 tagFile << " <anchorfile>" << convertToXML(fn) << "</anchorfile>\n";
4664 tagFile << " <anchor>" << convertToXML(anchor()) << "</anchor>\n";
4665 QCString idStr = id();
4666 if (!idStr.isEmpty())
4667 {
4668 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
4669 }
4670 tagFile << " <arglist>" << convertToXML(argsString()) << "</arglist>\n";
4671 if (isStrong())
4672 {
4673 for (const auto &fmd : m_enumFields)
4674 {
4675 if (!fmd->isReference())
4676 {
4677 tagFile << " <enumvalue file=\"" << convertToXML(fn);
4678 tagFile << "\" anchor=\"" << convertToXML(fmd->anchor());
4679 idStr = fmd->id();
4680 if (!idStr.isEmpty())
4681 {
4682 tagFile << "\" clangid=\"" << convertToXML(idStr);
4683 }
4684 tagFile << "\">" << convertToXML(fmd->name()) << "</enumvalue>\n";
4685 }
4686 }
4687 }
4688 writeDocAnchorsToTagFile(tagFile);
4689 tagFile << " </member>\n";
4690}
4691
4692void MemberDefImpl::_computeIsConstructor()
4693{
4694 m_isConstructorCached=1; // FALSE
4695 if (getClassDef())
4696 {
4697 if (m_isDMember) // for D
4698 {
4699 m_isConstructorCached = name()=="this" ? 2 : 1;
4700 return;
4701 }
4702 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4703 {
4704 m_isConstructorCached = name()=="__construct" ? 2 : 1;
4705 return;
4706 }
4707 else if (name()=="__init__" &&
4708 getLanguage()==SrcLangExt::Python) // for Python
4709 {
4710 m_isConstructorCached = 2; // TRUE
4711 return;
4712 }
4713 else // for other languages
4714 {
4715 QCString locName = getClassDef()->localName();
4716 int i=locName.find('<');
4717 if (i==-1) // not a template class
4718 {
4719 m_isConstructorCached = name()==locName ? 2 : 1;
4720 }
4721 else
4722 {
4723 m_isConstructorCached = name()==locName.left(i) ? 2 : 1;
4724 }
4725 return;
4726 }
4727 }
4728}
4729
4730bool MemberDefImpl::isConstructor() const
4731{
4732 if (m_isConstructorCached==0)
4733 {
4734 MemberDefImpl *that = const_cast<MemberDefImpl*>(this);
4735 that->_computeIsConstructor();
4736 }
4737 ASSERT(m_isConstructorCached>0);
4738 return m_isConstructorCached==2;
4739
4740}
4741
4742void MemberDefImpl::_computeIsDestructor()
4743{
4744 bool isDestructor = false;
4745 if (m_isDMember) // for D
4746 {
4747 isDestructor = name()=="~this";
4748 }
4749 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4750 {
4751 isDestructor = name()=="__destruct";
4752 }
4753 else if (name()=="__del__" &&
4754 getLanguage()==SrcLangExt::Python) // for Python
4755 {
4756 isDestructor = true;
4757 }
4758 else if (getLanguage()==SrcLangExt::Fortran) // for Fortran
4759 {
4760 isDestructor = typeString()=="final";
4761 }
4762 else // other languages
4763 {
4764 isDestructor =
4765 (name().find('~')!=-1 || name().find('!')!=-1) // The ! is for C++/CLI
4766 && name().find("operator")==-1;
4767 }
4768 m_isDestructorCached = isDestructor ? 2 : 1;
4769}
4770
4771bool MemberDefImpl::isDestructor() const
4772{
4773 if (m_isDestructorCached==0)
4774 {
4775 MemberDefImpl *that=const_cast<MemberDefImpl*>(this);
4776 that->_computeIsDestructor();
4777 }
4778 ASSERT(m_isDestructorCached>0);
4779 return m_isDestructorCached==2;
4780}
4781
4782void MemberDefImpl::writeEnumDeclaration(OutputList &typeDecl,
4783 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const
4784{
4785 int enumMemCount=0;
4786
4787 uint32_t numVisibleEnumValues=0;
4788 for (const auto &fmd : m_enumFields)
4789 {
4790 if (fmd->isBriefSectionVisible()) numVisibleEnumValues++;
4791 }
4792 if (numVisibleEnumValues==0 && !isBriefSectionVisible())
4793 {
4794 return;
4795 }
4796
4797 QCString n = name();
4798 int i=n.findRev("::");
4799 if (i!=-1) n=n.right(n.length()-i-2); // strip scope (TODO: is this needed?)
4800 if (n[0]!='@') // not an anonymous enum
4801 {
4802 if (isLinkableInProject() || hasDocumentedEnumValues())
4803 {
4804 //_writeTagData(compoundType);
4805 writeLink(typeDecl,cd,nd,fd,gd,mod);
4806 }
4807 else
4808 {
4809 typeDecl.startBold();
4810 typeDecl.docify(n);
4811 typeDecl.endBold();
4812 }
4813 typeDecl.writeChar(' ');
4814 }
4815 if (!m_enumBaseType.isEmpty())
4816 {
4817 typeDecl.writeChar(':');
4818 typeDecl.writeChar(' ');
4819 typeDecl.docify(m_enumBaseType);
4820 typeDecl.writeChar(' ');
4821 }
4822
4823 uint32_t enumValuesPerLine = static_cast<uint32_t>(Config_getInt(ENUM_VALUES_PER_LINE));
4824 if (numVisibleEnumValues>0 && enumValuesPerLine>0)
4825 {
4826 typeDecl.docify("{ ");
4827
4828 auto it = m_enumFields.begin();
4829 if (it!=m_enumFields.end())
4830 {
4831 const MemberDef *fmd=*it;
4832 bool fmdVisible = fmd->isBriefSectionVisible();
4833 bool first=true;
4834 while (fmd)
4835 {
4836 if (fmdVisible)
4837 {
4838 if (!first)
4839 {
4840 typeDecl.writeString(", ");
4841 }
4842 /* in html we start a new line after a number of items */
4843 if (numVisibleEnumValues>enumValuesPerLine
4844 && (enumMemCount%enumValuesPerLine)==0
4845 )
4846 {
4847 typeDecl.pushGeneratorState();
4848 typeDecl.disableAllBut(OutputType::Html);
4849 typeDecl.enable(OutputType::Latex);
4850 typeDecl.enable(OutputType::Docbook);
4851 typeDecl.lineBreak();
4852 typeDecl.disable(OutputType::Latex);
4853 typeDecl.disable(OutputType::Docbook);
4854 typeDecl.writeString("&#160;&#160;");
4855 typeDecl.popGeneratorState();
4856 }
4857
4858 if (fmd->hasDocumentation()) // enum value has docs
4859 {
4860 fmd->writeLink(typeDecl,cd,nd,fd,gd,mod);
4861 }
4862 else // no docs for this enum value
4863 {
4864 typeDecl.startBold();
4865 typeDecl.docify(fmd->name());
4866 typeDecl.endBold();
4867 }
4868 if (fmd->hasOneLineInitializer()) // enum value has initializer
4869 {
4870 //typeDecl.writeString(" = ");
4871 typeDecl.writeString(" ");
4872 typeDecl.parseText(fmd->initializer());
4873 }
4874 first=false;
4875 }
4876
4877 bool prevVisible = fmdVisible;
4878 ++it;
4879 if (it!=m_enumFields.end())
4880 {
4881 fmd=*it;
4882 }
4883 else
4884 {
4885 fmd=nullptr;
4886 }
4887 if (prevVisible)
4888 {
4889 typeDecl.disable(OutputType::Man);
4890 typeDecl.writeString("\n"); // to prevent too long lines in LaTeX
4891 typeDecl.enable(OutputType::Man);
4892 enumMemCount++;
4893 }
4894 }
4895 if (numVisibleEnumValues>enumValuesPerLine)
4896 {
4897 typeDecl.pushGeneratorState();
4898 typeDecl.disableAllBut(OutputType::Html);
4899 typeDecl.lineBreak();
4900 typeDecl.popGeneratorState();
4901 }
4902 }
4903 typeDecl.docify(" }");
4904 }
4905}
4906
4907void MemberDefImpl::moveArgumentList(std::unique_ptr<ArgumentList> al)
4908{
4909 m_defArgList = *al;
4910}
4911
4912void MemberDefImpl::moveDeclArgumentList(std::unique_ptr<ArgumentList> al)
4913{
4914 m_declArgList = *al;
4915}
4916
4921
4922void MemberDefImpl::setType(const QCString &t)
4923{
4924 m_type = t;
4925}
4926
4927void MemberDefImpl::setAccessorType(ClassDef *cd,const QCString &t)
4928{
4929 m_accessorClass = cd;
4930 m_accessorType = t;
4931}
4932
4937
4944
4950
4956
4962
4968
4973
4978
4979bool MemberDefImpl::isObjCMethod() const
4980{
4981 if (getClassDef() && getClassDef()->isObjectiveC() && isFunction()) return TRUE;
4982 return FALSE;
4983}
4984
4985bool MemberDefImpl::isObjCProperty() const
4986{
4987 if (getClassDef() && getClassDef()->isObjectiveC() && isProperty()) return TRUE;
4988 return FALSE;
4989}
4990
4991bool MemberDefImpl::isCSharpProperty() const
4992{
4993 if (getClassDef() && getClassDef()->isCSharp() && isProperty()) return TRUE;
4994 return FALSE;
4995}
4996
4997QCString MemberDefImpl::qualifiedName() const
4998{
4999 if (isObjCMethod())
5000 {
5001 QCString qm;
5002 if (isStatic()) qm="+"; else qm="-";
5003 qm+="[";
5004 qm+=getClassDef()->name()+" ";
5005 qm+=name();
5006 qm+="]";
5007 return qm;
5008 }
5009 else if (m_enumScope && m_enumScope->isStrong())
5010 {
5011 return m_enumScope->qualifiedName()+
5012 getLanguageSpecificSeparator(getLanguage())+
5013 localName();
5014 }
5015 else
5016 {
5017 return DefinitionMixin::qualifiedName();
5018 }
5019}
5020
5021void MemberDefImpl::setTagInfo(const TagInfo *ti)
5022{
5023 if (ti)
5024 {
5025 //printf("%s: Setting tag name=%s anchor=%s\n",qPrint(name()),qPrint(ti->tagName),qPrint(ti->anchor));
5026 m_anc=ti->anchor;
5027 setReference(ti->tagName);
5028 m_explicitOutputFileBase = stripExtension(ti->fileName);
5029 }
5030}
5031
5032QCString MemberDefImpl::objCMethodName(bool localLink,bool showStatic) const
5033{
5034 QCString qm;
5035 if (showStatic)
5036 {
5037 if (isStatic()) qm="+ "; else qm="- ";
5038 }
5039 qm+=name();
5040 if (!localLink) // link to method of same class
5041 {
5042 qm+=" (";
5043 qm+=getClassDef()->name();
5044 qm+=")";
5045 }
5046 return qm;
5047}
5048
5049QCString MemberDefImpl::declaration() const
5050{
5051 return m_decl;
5052}
5053
5054QCString MemberDefImpl::definition() const
5055{
5056 return m_def;
5057}
5058
5063
5064QCString MemberDefImpl::typeString() const
5065{
5066 return m_type;
5067}
5068
5069QCString MemberDefImpl::argsString() const
5070{
5071 return m_args;
5072}
5073
5074QCString MemberDefImpl::excpString() const
5075{
5076 return m_exception;
5077}
5078
5079QCString MemberDefImpl::bitfieldString() const
5080{
5081 return m_bitfields;
5082}
5083
5084const QCString &MemberDefImpl::initializer() const
5085{
5086 return m_initializer;
5087}
5088
5089int MemberDefImpl::initializerLines() const
5090{
5091 return m_initLines;
5092}
5093
5094bool MemberDefImpl::isDocTransferDone() const
5095{
5096 return m_docTransferDone;
5097}
5098
5103
5108
5109const ClassDef *MemberDefImpl::getClassDef() const
5110{
5111 return m_classDef;
5112}
5113
5118
5123
5124const FileDef *MemberDefImpl::getFileDef() const
5125{
5126 return m_fileDef;
5127}
5128
5129FileDef *MemberDefImpl::getFileDef()
5130{
5131 return m_fileDef;
5132}
5133
5134const NamespaceDef* MemberDefImpl::getNamespaceDef() const
5135{
5136 return m_nspace;
5137}
5138
5143
5144QCString MemberDefImpl::getReadAccessor() const
5145{
5146 return m_read;
5147}
5148
5149QCString MemberDefImpl::getWriteAccessor() const
5150{
5151 return m_write;
5152}
5153
5154const GroupDef *MemberDefImpl::getGroupDef() const
5155{
5156 return m_group;
5157}
5158
5159GroupDef *MemberDefImpl::getGroupDef()
5160{
5161 return m_group;
5162}
5163
5164const ModuleDef *MemberDefImpl::getModuleDef() const
5165{
5166 return m_moduleDef;
5167}
5168
5173
5178
5179int MemberDefImpl::getGroupStartLine() const
5180{
5181 return m_groupStartLine;
5182}
5183
5184bool MemberDefImpl::getGroupHasDocs() const
5185{
5186 return m_groupHasDocs;
5187}
5188
5189Protection MemberDefImpl::protection() const
5190{
5191 return m_prot;
5192}
5193
5194MemberType MemberDefImpl::memberType() const
5195{
5196 return m_mtype;
5197}
5198
5199bool MemberDefImpl::isSignal() const
5200{
5201 return m_mtype==MemberType::Signal;
5202}
5203
5204bool MemberDefImpl::isSlot() const
5205{
5206 return m_mtype==MemberType::Slot;
5207}
5208
5209bool MemberDefImpl::isVariable() const
5210{
5211 return m_mtype==MemberType::Variable;
5212}
5213
5214bool MemberDefImpl::isEnumerate() const
5215{
5216 return m_mtype==MemberType::Enumeration;
5217}
5218
5219bool MemberDefImpl::isEnumValue() const
5220{
5221 return m_mtype==MemberType::EnumValue;
5222}
5223
5224bool MemberDefImpl::isTypedef() const
5225{
5226 return m_mtype==MemberType::Typedef;
5227}
5228
5229bool MemberDefImpl::isSequence() const
5230{
5231 return m_mtype==MemberType::Sequence;
5232}
5233
5234bool MemberDefImpl::isDictionary() const
5235{
5236 return m_mtype==MemberType::Dictionary;
5237}
5238
5239bool MemberDefImpl::isFunction() const
5240{
5241 return m_mtype==MemberType::Function;
5242}
5243
5244bool MemberDefImpl::isFunctionPtr() const
5245{
5246 return m_mtype==MemberType::Variable && QCString(argsString()).find(")(")!=-1;
5247}
5248
5249bool MemberDefImpl::isDefine() const
5250{
5251 return m_mtype==MemberType::Define;
5252}
5253
5254bool MemberDefImpl::isFriend() const
5255{
5256 return m_mtype==MemberType::Friend;
5257}
5258
5259bool MemberDefImpl::isDCOP() const
5260{
5261 return m_mtype==MemberType::DCOP;
5262}
5263
5264bool MemberDefImpl::isProperty() const
5265{
5266 return m_mtype==MemberType::Property;
5267}
5268
5269bool MemberDefImpl::isEvent() const
5270{
5271 return m_mtype==MemberType::Event;
5272}
5273
5274bool MemberDefImpl::isRelated() const
5275{
5276 return m_related == Relationship::Related;
5277}
5278
5279bool MemberDefImpl::isForeign() const
5280{
5281 return m_related == Relationship::Foreign;
5282}
5283
5284bool MemberDefImpl::isStatic() const
5285{
5286 return m_stat;
5287}
5288
5289bool MemberDefImpl::isInline() const
5290{
5291 return m_memSpec.isInline();
5292}
5293
5294bool MemberDefImpl::isExplicit() const
5295{
5296 return m_memSpec.isExplicit();
5297}
5298
5299bool MemberDefImpl::isMutable() const
5300{
5301 return m_memSpec.isMutable();
5302}
5303
5304bool MemberDefImpl::isThreadLocal() const
5305{
5306 return m_memSpec.isThreadLocal();
5307}
5308
5309bool MemberDefImpl::isGettable() const
5310{
5311 return m_memSpec.isGettable();
5312}
5313
5314bool MemberDefImpl::isPrivateGettable() const
5315{
5316 return m_memSpec.isPrivateGettable();
5317}
5318
5319bool MemberDefImpl::isProtectedGettable() const
5320{
5321 return m_memSpec.isProtectedGettable();
5322}
5323
5324bool MemberDefImpl::isSettable() const
5325{
5326 return m_memSpec.isSettable();
5327}
5328
5329bool MemberDefImpl::isPrivateSettable() const
5330{
5331 return m_memSpec.isPrivateSettable();
5332}
5333
5334bool MemberDefImpl::isProtectedSettable() const
5335{
5336 return m_memSpec.isProtectedSettable();
5337}
5338
5339bool MemberDefImpl::isAddable() const
5340{
5341 return m_memSpec.isAddable();
5342}
5343
5344bool MemberDefImpl::isRemovable() const
5345{
5346 return m_memSpec.isRemovable();
5347}
5348
5349bool MemberDefImpl::isRaisable() const
5350{
5351 return m_memSpec.isRaisable();
5352}
5353
5354bool MemberDefImpl::isReadable() const
5355{
5356 return m_memSpec.isReadable();
5357}
5358
5359bool MemberDefImpl::isWritable() const
5360{
5361 return m_memSpec.isWritable();
5362}
5363
5364bool MemberDefImpl::isFinal() const
5365{
5366 return m_memSpec.isFinal();
5367}
5368
5369bool MemberDefImpl::isNew() const
5370{
5371 return m_memSpec.isNew();
5372}
5373
5374bool MemberDefImpl::isSealed() const
5375{
5376 return m_memSpec.isSealed();
5377}
5378
5379bool MemberDefImpl::isOverride() const
5380{
5381 return m_memSpec.isOverride();
5382}
5383
5384bool MemberDefImpl::isInitonly() const
5385{
5386 return m_memSpec.isInitonly();
5387}
5388
5389bool MemberDefImpl::isAbstract() const
5390{
5391 return m_memSpec.isAbstract();
5392}
5393
5394bool MemberDefImpl::isOptional() const
5395{
5396 return m_memSpec.isOptional();
5397}
5398
5399bool MemberDefImpl::isRequired() const
5400{
5401 return m_memSpec.isRequired();
5402}
5403
5404bool MemberDefImpl::isNonAtomic() const
5405{
5406 return m_memSpec.isNonAtomic();
5407}
5408
5409bool MemberDefImpl::isCopy() const
5410{
5411 return m_memSpec.isCopy();
5412}
5413
5414bool MemberDefImpl::isAssign() const
5415{
5416 return m_memSpec.isAssign();
5417}
5418
5419bool MemberDefImpl::isRetain() const
5420{
5421 return m_memSpec.isRetain();
5422}
5423
5424bool MemberDefImpl::isWeak() const
5425{
5426 return m_memSpec.isWeak();
5427}
5428
5429bool MemberDefImpl::isStrong() const
5430{
5431 return m_memSpec.isStrong();
5432}
5433
5434bool MemberDefImpl::isEnumStruct() const
5435{
5436 return m_memSpec.isEnumStruct();
5437}
5438
5439bool MemberDefImpl::isStrongEnumValue() const
5440{
5441 return m_mtype==MemberType::EnumValue &&
5442 m_enumScope &&
5443 m_enumScope->isStrong();
5444}
5445
5446bool MemberDefImpl::isUnretained() const
5447{
5448 return m_memSpec.isUnretained();
5449}
5450
5451bool MemberDefImpl::isTypeAlias() const
5452{
5453 return m_memSpec.isAlias();
5454}
5455
5456bool MemberDefImpl::isDefault() const
5457{
5458 return m_memSpec.isDefault();
5459}
5460
5461bool MemberDefImpl::isDelete() const
5462{
5463 return m_memSpec.isDelete();
5464}
5465
5466bool MemberDefImpl::isNoExcept() const
5467{
5468 return m_memSpec.isNoExcept();
5469}
5470
5471bool MemberDefImpl::isAttribute() const
5472{
5473 return m_memSpec.isAttribute();
5474}
5475
5476bool MemberDefImpl::isUNOProperty() const
5477{
5478 return m_memSpec.isProperty();
5479}
5480
5481bool MemberDefImpl::isReadonly() const
5482{
5483 return m_memSpec.isReadonly();
5484}
5485
5486bool MemberDefImpl::isBound() const
5487{
5488 return m_memSpec.isBound();
5489}
5490
5491bool MemberDefImpl::isConstrained() const
5492{
5493 return m_memSpec.isConstrained();
5494}
5495
5496bool MemberDefImpl::isTransient() const
5497{
5498 return m_memSpec.isTransient();
5499}
5500
5501bool MemberDefImpl::isMaybeVoid() const
5502{
5503 return m_memSpec.isMaybeVoid();
5504}
5505
5506bool MemberDefImpl::isMaybeDefault() const
5507{
5508 return m_memSpec.isMaybeDefault();
5509}
5510
5511bool MemberDefImpl::isMaybeAmbiguous() const
5512{
5513 return m_memSpec.isMaybeAmbiguous();
5514}
5515
5516bool MemberDefImpl::isPublished() const
5517{
5518 return m_memSpec.isPublished();
5519}
5520
5521
5522bool MemberDefImpl::isImplementation() const
5523{
5524 return m_implOnly;
5525}
5526
5527bool MemberDefImpl::isExternal() const
5528{
5529 return m_explExt;
5530}
5531
5532bool MemberDefImpl::isTemplateSpecialization() const
5533{
5534 return m_tspec;
5535}
5536
5537bool MemberDefImpl::isCallable() const
5538{
5539 return isFunction() ||
5540 isSlot() ||
5541 isSignal() ||
5542 isConstructor() ||
5543 isDestructor() ||
5544 isObjCMethod() ||
5545 isFriend();
5546}
5547
5548ClassDef *MemberDefImpl::relatedAlso() const
5549{
5550 return m_relatedAlso;
5551}
5552
5553bool MemberDefImpl::hasDocumentedEnumValues() const
5554{
5555 return m_docEnumValues;
5556}
5557
5558const MemberDef *MemberDefImpl::getAnonymousEnumType() const
5559{
5560 return m_annEnumType;
5561}
5562
5563bool MemberDefImpl::isDocsForDefinition() const
5564{
5565 return m_docsForDefinition;
5566}
5567
5568const MemberDef *MemberDefImpl::getEnumScope() const
5569{
5570 return m_enumScope;
5571}
5572
5573bool MemberDefImpl::livesInsideEnum() const
5574{
5575 return m_livesInsideEnum;
5576}
5577
5578bool MemberDefImpl::isSliceLocal() const
5579{
5580 return m_memSpec.isLocal();
5581}
5582
5583bool MemberDefImpl::isNoDiscard() const
5584{
5585 return m_memSpec.isNoDiscard();
5586}
5587
5588bool MemberDefImpl::isConstExpr() const
5589{
5590 return m_memSpec.isConstExpr();
5591}
5592
5593bool MemberDefImpl::isConstEval() const
5594{
5595 return m_memSpec.isConstEval();
5596}
5597
5598bool MemberDefImpl::isConstInit() const
5599{
5600 return m_memSpec.isConstInit();
5601}
5602
5603const MemberVector &MemberDefImpl::enumFieldList() const
5604{
5605 return m_enumFields;
5606}
5607
5608const ExampleList &MemberDefImpl::getExamples() const
5609{
5610 return m_examples;
5611}
5612
5613bool MemberDefImpl::isPrototype() const
5614{
5615 return m_proto;
5616}
5617
5618const ArgumentList &MemberDefImpl::argumentList() const
5619{
5620 return m_defArgList;
5621}
5622
5623const ArgumentList &MemberDefImpl::declArgumentList() const
5624{
5625 return m_declArgList;
5626}
5627
5628void MemberDefImpl::resolveUnnamedParameters(const MemberDef *md)
5629{
5630 ArgumentList &decAl = m_declArgList;
5631 ArgumentList &defAl = m_defArgList;
5632 const ArgumentList &decAlSrc = md->declArgumentList();
5633 const ArgumentList &defAlSrc = md->argumentList();
5634 auto decSrc = decAlSrc.begin(), defSrc = defAlSrc.begin();
5635 for (auto decIt = decAl.begin(), defIt = defAl.begin();
5636 decIt != decAl.end() && defIt != defAl.end() && decSrc != decAlSrc.end() && defSrc != defAlSrc.end();
5637 ++decIt, ++defIt, ++decSrc, ++defSrc++)
5638 {
5639 Argument &decA = *decIt;
5640 Argument &defA = *defIt;
5641 const Argument &decAS = *decSrc;
5642 const Argument &defAS = *defSrc;
5643 if (decA.name.isEmpty())
5644 {
5645 if (!defA.name.isEmpty())
5646 {
5647 decA.name = defA.name;
5648 }
5649 else if (!decAS.name.isEmpty())
5650 {
5651 decA.name = decAS.name;
5652 }
5653 else if (!defAS.name.isEmpty())
5654 {
5655 decA.name = defAS.name;
5656 }
5657 }
5658 if (defA.name.isEmpty())
5659 {
5660 if (!decA.name.isEmpty())
5661 {
5662 defA.name = decA.name;
5663 }
5664 else if (!decAS.name.isEmpty())
5665 {
5666 defA.name = decAS.name;
5667 }
5668 else if (!defAS.name.isEmpty())
5669 {
5670 defA.name = defAS.name;
5671 }
5672 }
5673 }
5674}
5675
5676const ArgumentList &MemberDefImpl::templateArguments() const
5677{
5678 return m_tArgList;
5679}
5680
5685
5686int MemberDefImpl::getMemberGroupId() const
5687{
5688 return m_grpId;
5689}
5690
5695
5696bool MemberDefImpl::fromAnonymousScope() const
5697{
5698 return m_annScope;
5699}
5700
5701bool MemberDefImpl::hasCallGraph() const
5702{
5703 return m_hasCallGraph;
5704}
5705
5706bool MemberDefImpl::_hasVisibleCallGraph() const
5707{
5708 bool enabled = m_hasCallGraph &&
5709 (isFunction() || isSlot() || isSignal()) &&
5710 Config_getBool(HAVE_DOT);
5711 if (enabled)
5712 {
5713 bool trivial = DotCallGraph::isTrivial(this,FALSE);
5714 return !trivial;
5715 }
5716 return FALSE;
5717}
5718
5719bool MemberDefImpl::hasCallerGraph() const
5720{
5721 return m_hasCallerGraph;
5722}
5723
5724bool MemberDefImpl::_hasVisibleCallerGraph() const
5725{
5726 bool enabled = m_hasCallerGraph &&
5727 (isFunction() || isSlot() || isSignal()) &&
5728 Config_getBool(HAVE_DOT);
5729 if (enabled)
5730 {
5731 bool trivial = DotCallGraph::isTrivial(this,TRUE);
5732 return !trivial;
5733 }
5734 return FALSE;
5735}
5736
5741
5746
5747bool MemberDefImpl::hasInlineSource() const
5748{
5749 return m_hasInlineSource;
5750}
5751
5752bool MemberDefImpl::hasEnumValues() const
5753{
5754 return m_hasEnumValues;
5755}
5756
5757const MemberDef *MemberDefImpl::templateMaster() const
5758{
5759 return m_templateMaster;
5760}
5761
5762std::optional<ArgumentList> MemberDefImpl::formalTemplateArguments() const
5763{
5764 return m_formalTemplateArguments;
5765}
5766
5767bool MemberDefImpl::isTypedefValCached() const
5768{
5769 return m_isTypedefValCached;
5770}
5771
5776
5781
5782QCString MemberDefImpl::getCachedResolvedTypedef() const
5783{
5784 //printf("MemberDefImpl::getCachedResolvedTypedef()=%s\n",qPrint(m_cachedResolvedType));
5785 return m_cachedResolvedType;
5786}
5787
5788MemberDef *MemberDefImpl::memberDefinition() const
5789{
5790 return m_memDef;
5791}
5792
5793MemberDef *MemberDefImpl::memberDeclaration() const
5794{
5795 return m_memDec;
5796}
5797
5798const MemberDef *MemberDefImpl::inheritsDocsFrom() const
5799{
5800 return m_docProvider;
5801}
5802
5803const MemberDef *MemberDefImpl::getGroupAlias() const
5804{
5805 return m_groupAlias;
5806}
5807
5812
5813int MemberDefImpl::getDeclLine() const
5814{
5815 return m_declLine;
5816}
5817
5818int MemberDefImpl::getDeclColumn() const
5819{
5820 return m_declColumn;
5821}
5822
5823
5824//----------------------------------------------
5825
5831
5832void MemberDefImpl::setDefinition(const QCString &d)
5833{
5834 m_def=d;
5835}
5836
5844
5845void MemberDefImpl::setModuleDef(ModuleDef *mod)
5846{
5847 m_moduleDef=mod;
5848}
5849
5855
5860
5865
5870
5875
5876void MemberDefImpl::addQualifiers(const StringVector &qualifiers)
5877{
5878 for (const auto &sx : qualifiers)
5879 {
5880 bool alreadyAdded = std::find(m_qualifiers.begin(), m_qualifiers.end(), sx) != m_qualifiers.end();
5881 if (!alreadyAdded)
5882 {
5883 m_qualifiers.push_back(sx);
5884 }
5885 }
5886}
5887
5892
5893void MemberDefImpl::setMaxInitLines(int lines)
5894{
5895 if (lines!=-1)
5896 {
5897 m_userInitLines=lines;
5898 }
5899}
5900
5901void MemberDefImpl::setReadAccessor(const QCString &r)
5902{
5903 m_read=r;
5904}
5905
5906void MemberDefImpl::setWriteAccessor(const QCString &w)
5907{
5908 m_write=w;
5909}
5910
5911void MemberDefImpl::setTemplateSpecialization(bool b)
5912{
5913 m_tspec=b;
5914}
5915
5916void MemberDefImpl::makeRelated()
5917{
5918 m_related = Relationship::Related;
5919 m_isLinkableCached = 0;
5920}
5921
5922void MemberDefImpl::makeForeign()
5923{
5924 m_related = Relationship::Foreign;
5925 m_isLinkableCached = 0;
5926}
5927
5928void MemberDefImpl::setInheritsDocsFrom(const MemberDef *md)
5929{
5930 m_docProvider = md;
5931}
5932
5933void MemberDefImpl::setArgsString(const QCString &as)
5934{
5935 m_args = as;
5936}
5937
5942
5949
5950void MemberDefImpl::setDocumentedEnumValues(bool value)
5951{
5952 m_docEnumValues=value;
5953}
5954
5955void MemberDefImpl::setAnonymousEnumType(const MemberDef *md)
5956{
5957 m_annEnumType = md;
5958}
5959
5960void MemberDefImpl::setPrototype(bool p,const QCString &df,int line,int column)
5961{
5962 m_proto=p;
5963 if (p)
5964 {
5965 setDeclFile(df,line,column);
5966 }
5967 else
5968 {
5969 setDefFile(df,line,column);
5970 }
5971}
5972
5973void MemberDefImpl::setExplicitExternal(bool b,const QCString &df,int line,int column)
5974{
5975 m_explExt=b;
5976 if (b)
5977 {
5978 setDeclFile(df,line,column);
5979 }
5980 else
5981 {
5982 setDefFile(df,line,column);
5983 }
5984}
5985
5986void MemberDefImpl::setDeclFile(const QCString &df,int line,int column)
5987{
5988 m_declFileName = df;
5989 m_declLine = line;
5990 m_declColumn = column;
5991}
5992
5993void MemberDefImpl::setMemberGroupId(int id)
5994{
5995 m_grpId=id;
5996}
5997
6002
6003void MemberDefImpl::setFromAnonymousScope(bool b)
6004{
6005 m_annScope=b;
6006}
6007
6012
6017
6023
6028
6033
6034void MemberDefImpl::setGroupAlias(const MemberDef *md)
6035{
6036 m_groupAlias = md;
6037}
6038
6043
6048
6053
6054ClassDef *MemberDefImpl::category() const
6055{
6056 return m_category;
6057}
6058
6059void MemberDefImpl::setCategory(ClassDef *def)
6060{
6061 m_category = def;
6062}
6063
6064const MemberDef *MemberDefImpl::categoryRelation() const
6065{
6066 return m_categoryRelation;
6067}
6068
6073
6074void MemberDefImpl::setEnumBaseType(const QCString &type)
6075{
6076 m_enumBaseType = type;
6077}
6078
6079QCString MemberDefImpl::enumBaseType() const
6080{
6081 return m_enumBaseType;
6082}
6083
6084void MemberDefImpl::setRequiresClause(const QCString &req)
6085{
6086 m_requiresClause = req;
6087}
6088
6093
6094void MemberDefImpl::cacheTypedefVal(const ClassDef*val, const QCString & templSpec, const QCString &resolvedType)
6095{
6096 m_isTypedefValCached=TRUE;
6097 m_cachedTypedefValue=val;
6098 m_cachedTypedefTemplSpec=templSpec;
6099 m_cachedResolvedType=resolvedType;
6100 //printf("MemberDefImpl::cacheTypedefVal=%s m_impl=%p\n",qPrint(m_cachedResolvedType),m_impl);
6101}
6102
6103void MemberDefImpl::copyArgumentNames(const MemberDef *bmd)
6104{
6105 {
6106 const ArgumentList &srcAl = bmd->argumentList();
6107 ArgumentList &dstAl = m_defArgList;
6108 auto srcIt = srcAl.begin();
6109 auto dstIt = dstAl.begin();
6110 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6111 {
6112 Argument &argDst = *dstIt;
6113 const Argument &argSrc = *srcIt;
6114 if (!argSrc.name.isEmpty())
6115 {
6116 argDst.name = argSrc.name;
6117 }
6118 argDst.docs = argSrc.docs;
6119 ++srcIt;
6120 ++dstIt;
6121 }
6122 }
6123
6124 {
6125 const ArgumentList &srcAl = bmd->declArgumentList();
6126 ArgumentList &dstAl = m_declArgList;
6127 auto srcIt = srcAl.begin();
6128 auto dstIt = dstAl.begin();
6129
6130 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6131 {
6132 Argument &argDst = *dstIt;
6133 const Argument &argSrc = *srcIt;
6134 if (!argSrc.name.isEmpty())
6135 {
6136 argDst.name = argSrc.name;
6137 }
6138 argDst.docs = argSrc.docs;
6139 ++srcIt;
6140 ++dstIt;
6141 }
6142 }
6143}
6144
6145static void invalidateCachedTypesInArgumentList(ArgumentList &al)
6146{
6147 for (Argument &a : al)
6148 {
6149 a.canType.clear();
6150 }
6151}
6152
6158
6163
6164int MemberDefImpl::numberOfFlowKeyWords() const
6165{
6166 return m_numberOfFlowKW;
6167}
6168
6169//----------------
6170
6171QCString MemberDefImpl::displayName(bool) const
6172{
6173 return DefinitionMixin::name();
6174}
6175
6176//----------------
6177
6178static void transferArgumentDocumentation(ArgumentList &decAl,ArgumentList &defAl)
6179{
6180 for (auto decIt = decAl.begin(), defIt = defAl.begin();
6181 decIt!= decAl.end() && defIt!= defAl.end();
6182 ++decIt, ++defIt)
6183 {
6184 Argument &decA = *decIt;
6185 Argument &defA = *defIt;
6186 if (decA.docs.isEmpty() && !defA.docs.isEmpty())
6187 {
6188 decA.docs = defA.docs;
6189 }
6190 else if (defA.docs.isEmpty() && !decA.docs.isEmpty())
6191 {
6192 defA.docs = decA.docs;
6193 }
6194 //printf("transferArgumentDocumentation(%s<->%s)\n",qPrint(decA.name),qPrint(defA.name));
6195 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6196 {
6197 if (decA.name.isEmpty() && !defA.name.isEmpty())
6198 {
6199 decA.name = defA.name;
6200 }
6201 else if (defA.name.isEmpty() && !decA.name.isEmpty())
6202 {
6203 defA.name = decA.name;
6204 }
6205 }
6206 }
6207}
6208
6209void combineDeclarationAndDefinition(MemberDefMutable *mdec,MemberDefMutable *mdef)
6210{
6211 AUTO_TRACE("mdec='{}' mdef='{}' mdec.isPrototype={} mdef.isPrototype={}",
6212 mdec->name(), mdef->name(), mdec->isPrototype(), mdef->isPrototype());
6213 if (
6214 (!mdef->isDocTransferDone() || !mdec->isDocTransferDone()) &&
6215 (
6216 (mdef->isFunction() && !mdef->isStatic() && !mdef->isPrototype()) ||
6217 (mdef->isVariable() && !mdef->isExternal() && !mdef->isStatic())
6218 )
6219 )
6220 {
6221 bool sameNumTemplateArgs = mdef->templateArguments().size()==mdec->templateArguments().size();
6222
6223 ArgumentList &mdefAl = const_cast<ArgumentList&>(mdef->argumentList());
6224 ArgumentList &mdecAl = const_cast<ArgumentList&>(mdec->argumentList());
6225 if (sameNumTemplateArgs &&
6226 matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),mdef->typeString(),&mdefAl,
6227 mdec->getOuterScope(),mdec->getFileDef(),mdec->typeString(),&mdecAl,
6228 TRUE,mdef->getLanguage()
6229 )
6230 ) /* match found */
6231 {
6232 AUTO_TRACE_ADD("combining definition and declaration");
6233
6234 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6235 {
6236 mdec->resolveUnnamedParameters(mdef);
6237 }
6238
6239 // first merge argument documentation
6240 transferArgumentDocumentation(mdecAl,mdefAl);
6241
6242 // copy brief description between definition and declaration
6243 QCString mdefBrief = mdef->briefDescription();
6244 QCString mdecBrief = mdec->briefDescription();
6245 QCString mdefBriefFile = mdef->briefFile();
6246 QCString mdecBriefFile = mdec->briefFile();
6247 int mdefBriefLine = mdef->briefLine();
6248 int mdecBriefLine = mdec->briefLine();
6249 if (!mdef->isDocTransferDone() && !mdecBrief.isEmpty())
6250 {
6251 mdef->setBriefDescription(mdecBrief,mdecBriefFile,mdecBriefLine);
6252 }
6253 if (!mdec->isDocTransferDone() && !mdefBrief.isEmpty())
6254 {
6255 mdec->setBriefDescription(mdefBrief,mdefBriefFile,mdefBriefLine);
6256 }
6257
6258 // copy detailed description between definition and declaration
6259 QCString mdefDocs = mdef->documentation();
6260 QCString mdecDocs = mdec->documentation();
6261 QCString mdefFile = mdef->docFile();
6262 QCString mdecFile = mdec->docFile();
6263 int mdefLine = mdef->docLine();
6264 int mdecLine = mdec->docLine();
6265 bool mdefDocsForDef = mdef->isDocsForDefinition();
6266 bool mdecDocsForDef = mdec->isDocsForDefinition();
6267 if (!mdec->isDocTransferDone() && !mdefDocs.isEmpty())
6268 {
6269 //printf("transferring docs mdef->mdec (%s->%s)\n",mdef->argsString(),mdec->argsString());
6270 mdec->setDocumentation(mdefDocs,mdefFile,mdefLine);
6271 mdec->setDocsForDefinition(mdefDocsForDef);
6272 if (mdefAl.hasParameters())
6273 {
6274 auto mdefAlComb = stringToArgumentList(mdef->getLanguage(),mdef->argsString());
6275 transferArgumentDocumentation(mdefAl,*mdefAlComb);
6276 mdec->moveArgumentList(std::move(mdefAlComb));
6277 }
6278 }
6279 if (!mdef->isDocTransferDone() && !mdecDocs.isEmpty())
6280 {
6281 //printf("transferring docs mdec->mdef (%s->%s)\n",mdec->argsString(),mdef->argsString());
6282 mdef->setDocumentation(mdecDocs,mdecFile,mdecLine);
6283 mdef->setDocsForDefinition(mdecDocsForDef);
6284 if (mdecAl.hasParameters())
6285 {
6286 auto mdecAlComb = stringToArgumentList(mdec->getLanguage(),mdec->argsString());
6287 transferArgumentDocumentation(mdecAl,*mdecAlComb);
6288 mdef->moveDeclArgumentList(std::move(mdecAlComb));
6289 }
6290 }
6291
6292 // copy inbody documentation between definition and declaration
6293 QCString mdefInbodyDocs = mdef->inbodyDocumentation();
6294 QCString mdecInbodyDocs = mdec->inbodyDocumentation();
6295 QCString mdefInbodyFile = mdef->inbodyFile();
6296 QCString mdecInbodyFile = mdec->inbodyFile();
6297 int mdefInbodyLine = mdef->inbodyLine();
6298 int mdecInbodyLine = mdec->inbodyLine();
6299 if (!mdec->isDocTransferDone() && !mdefInbodyDocs.isEmpty())
6300 {
6301 mdec->setInbodyDocumentation(mdefInbodyDocs,mdefInbodyFile,mdefInbodyLine);
6302 }
6303 if (!mdef->isDocTransferDone() && !mdecInbodyDocs.isEmpty())
6304 {
6305 mdef->setInbodyDocumentation(mdecInbodyDocs,mdecInbodyFile,mdecInbodyLine);
6306 }
6307
6308 if (mdec->getStartBodyLine()!=-1 && mdef->getStartBodyLine()==-1)
6309 {
6310 //printf("body mdec->mdef %d-%d\n",mdec->getStartBodyLine(),mdef->getEndBodyLine());
6311 mdef->setBodySegment(mdec->getDefLine(),mdec->getStartBodyLine(),mdec->getEndBodyLine());
6312 mdef->setBodyDef(mdec->getBodyDef());
6313 //mdef->setBodyMember(mdec);
6314 }
6315 else if (mdef->getStartBodyLine()!=-1 && mdec->getStartBodyLine()==-1)
6316 {
6317 //printf("body mdef->mdec %d-%d\n",mdef->getStartBodyLine(),mdec->getEndBodyLine());
6318 mdec->setBodySegment(mdef->getDefLine(),mdef->getStartBodyLine(),mdef->getEndBodyLine());
6319 mdec->setBodyDef(mdef->getBodyDef());
6320 //mdec->setBodyMember(mdef);
6321 }
6322 mdec->mergeMemberSpecifiers(mdef->getMemberSpecifiers());
6323 mdef->mergeMemberSpecifiers(mdec->getMemberSpecifiers());
6324
6325 // copy group info.
6326 if (mdec->getGroupDef()==nullptr && mdef->getGroupDef()!=nullptr)
6327 {
6328 mdec->setGroupDef(mdef->getGroupDef(),
6329 mdef->getGroupPri(),
6330 mdef->docFile(),
6331 mdef->docLine(),
6332 mdef->hasDocumentation(),
6333 mdef
6334 );
6335 }
6336 else if (mdef->getGroupDef()==nullptr && mdec->getGroupDef()!=nullptr)
6337 {
6338 mdef->setGroupDef(mdec->getGroupDef(),
6339 mdec->getGroupPri(),
6340 mdec->docFile(),
6341 mdec->docLine(),
6342 mdec->hasDocumentation(),
6343 mdec
6344 );
6345 }
6346
6347
6348 mdec->mergeRefItems(mdef);
6349 mdef->mergeRefItems(mdec);
6350
6351 mdef->setMemberDeclaration(mdec);
6352 mdec->setMemberDefinition(mdef);
6353
6354 mergeMemberOverrideOptions(mdec,mdef);
6355
6356 mdef->addQualifiers(mdec->getQualifiers());
6357 mdec->addQualifiers(mdef->getQualifiers());
6358
6359 mdef->setDocTransferDone();
6360 mdec->setDocTransferDone();
6361 }
6362 }
6363}
6364
6365QCString MemberDefImpl::briefDescription(bool abbr) const
6366{
6367 if (m_templateMaster)
6368 {
6369 return m_templateMaster->briefDescription(abbr);
6370 }
6371 else
6372 {
6373 return DefinitionMixin::briefDescription(abbr);
6374 }
6375}
6376
6377QCString MemberDefImpl::documentation() const
6378{
6379 if (m_templateMaster)
6380 {
6381 return m_templateMaster->documentation();
6382 }
6383 else
6384 {
6385 return DefinitionMixin::documentation();
6386 }
6387}
6388
6389bool MemberDefImpl::hasUserDocumentation() const
6390{
6391 if (m_templateMaster)
6392 {
6393 return m_templateMaster->hasUserDocumentation();
6394 }
6395 else
6396 {
6397 return DefinitionMixin::hasUserDocumentation();
6398 }
6399}
6400
6401const ArgumentList &MemberDefImpl::typeConstraints() const
6402{
6403 return m_typeConstraints;
6404}
6405
6406bool MemberDefImpl::isFriendToHide() const
6407{
6408 bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
6409 bool isFriendToHide = hideFriendCompounds &&
6410 (m_type=="friend class" ||
6411 m_type=="friend struct" ||
6412 m_type=="friend union");
6413 return isFriendToHide;
6414}
6415
6416bool MemberDefImpl::isFriendClass() const
6417{
6418 return (isFriend() &&
6419 (m_type=="friend class" || m_type=="friend struct" ||
6420 m_type=="friend union"));
6421}
6422
6423
6424bool MemberDefImpl::isNotFriend() const
6425{
6426 return !(isFriend() && isFriendToHide());
6427}
6428
6429bool MemberDefImpl::isFunctionOrSignalSlot() const
6430{
6431 return isFunction() || isSlot() || isSignal();
6432}
6433
6434bool MemberDefImpl::isRelatedOrFriend() const
6435{
6436 return isRelated() || isForeign() || (isFriend() && !isFriendToHide());
6437}
6438
6439bool MemberDefImpl::isReference() const
6440{
6441 return DefinitionMixin::isReference() ||
6442 (m_templateMaster && m_templateMaster->isReference());
6443}
6444
6445CodeSymbolType MemberDefImpl::codeSymbolType() const
6446{
6447 switch (memberType())
6448 {
6449 case MemberType::Define: return CodeSymbolType::Define;
6450 case MemberType::Function: return CodeSymbolType::Function;
6451 case MemberType::Variable: return CodeSymbolType::Variable;
6452 case MemberType::Typedef: return CodeSymbolType::Typedef;
6453 case MemberType::Enumeration: return CodeSymbolType::Enumeration;
6454 case MemberType::EnumValue: return CodeSymbolType::EnumValue;
6455 case MemberType::Signal: return CodeSymbolType::Signal;
6456 case MemberType::Slot: return CodeSymbolType::Slot;
6457 case MemberType::Friend: return CodeSymbolType::Friend;
6458 case MemberType::DCOP: return CodeSymbolType::DCOP;
6459 case MemberType::Property: return CodeSymbolType::Property;
6460 case MemberType::Event: return CodeSymbolType::Event;
6461 case MemberType::Interface: return CodeSymbolType::Interface;
6462 case MemberType::Service: return CodeSymbolType::Service;
6463 case MemberType::Sequence: return CodeSymbolType::Sequence;
6464 case MemberType::Dictionary: return CodeSymbolType::Dictionary;
6465 }
6466 return CodeSymbolType::Default;
6467}
6468
6469int MemberDefImpl::redefineCount() const
6470{
6471 return m_redefineCount;
6472}
6473
6474void MemberDefImpl::setRedefineCount(int count)
6475{
6476 m_redefineCount=count;
6477}
6478
6479//-------------------------------------------------------------------------------
6480// Helpers
6481
6482static std::mutex g_docCrossReferenceMutex;
6483
6484void addDocCrossReference(const MemberDef *s,const MemberDef *d)
6485{
6486 MemberDefMutable *src = toMemberDefMutable(const_cast<MemberDef*>(s));
6487 MemberDefMutable *dst = toMemberDefMutable(const_cast<MemberDef*>(d));
6488 if (src==nullptr || dst==nullptr) return;
6489 //printf("--> addDocCrossReference src=%s,dst=%s\n",qPrint(src->name()),qPrint(dst->name()));
6490 if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types
6491 if ((dst->hasReferencedByRelation() || dst->hasCallerGraph()) &&
6492 src->isCallable()
6493 )
6494 {
6495 QCString sourceRefName = src->sourceRefName();
6496 MemberDefMutable *mdDef = toMemberDefMutable(dst->memberDefinition());
6497 MemberDefMutable *mdDecl = toMemberDefMutable(dst->memberDeclaration());
6498
6499 // ---- critical section
6500 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6501 dst->addSourceReferencedBy(src,sourceRefName);
6502 if (mdDef)
6503 {
6504 mdDef->addSourceReferencedBy(src,sourceRefName);
6505 }
6506 if (mdDecl)
6507 {
6508 mdDecl->addSourceReferencedBy(src,sourceRefName);
6509 }
6510 // ---- end critical section
6511 }
6512 if ((src->hasReferencesRelation() || src->hasCallGraph()) &&
6513 src->isCallable()
6514 )
6515 {
6516 QCString sourceRefName = dst->sourceRefName();
6517 MemberDefMutable *mdDef = toMemberDefMutable(src->memberDefinition());
6518 MemberDefMutable *mdDecl = toMemberDefMutable(src->memberDeclaration());
6519
6520 // ---- critical section
6521 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6522 src->addSourceReferences(dst,sourceRefName);
6523 if (mdDef)
6524 {
6525 mdDef->addSourceReferences(dst,sourceRefName);
6526 }
6527 if (mdDecl)
6528 {
6529 mdDecl->addSourceReferences(dst,sourceRefName);
6530 }
6531 // ---- end critical section
6532 }
6533}
6534
6535// --- Cast functions
6536//
6537MemberDef *toMemberDef(Definition *d)
6538{
6539 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6540 {
6541 return static_cast<MemberDef*>(d);
6542 }
6543 else
6544 {
6545 return nullptr;
6546 }
6547}
6548
6549MemberDef *toMemberDef(DefinitionMutable *md)
6550{
6551 Definition *d = toDefinition(md);
6552 if (d && typeid(*d)==typeid(MemberDefImpl))
6553 {
6554 return static_cast<MemberDef*>(d);
6555 }
6556 else
6557 {
6558 return nullptr;
6559 }
6560}
6561
6562const MemberDef *toMemberDef(const Definition *d)
6563{
6564 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6565 {
6566 return static_cast<const MemberDef*>(d);
6567 }
6568 else
6569 {
6570 return nullptr;
6571 }
6572}
6573
6574MemberDefMutable *toMemberDefMutable(Definition *d)
6575{
6576 if (d && typeid(*d)==typeid(MemberDefImpl))
6577 {
6578 return static_cast<MemberDefMutable*>(d);
6579 }
6580 else
6581 {
6582 return nullptr;
6583 }
6584}
6585
6586
prefix
constexpr auto prefix
Definition anchor.cpp:44
ArgumentLists
std::vector< ArgumentList > ArgumentLists
Definition arguments.h:147
ArgumentList
This class represents an function or template argument list.
Definition arguments.h:65
ArgumentList::refQualifier
RefQualifierType refQualifier() const
Definition arguments.h:116
ArgumentList::end
iterator end()
Definition arguments.h:94
ArgumentList::hasParameters
bool hasParameters() const
Definition arguments.h:76
ArgumentList::trailingReturnType
QCString trailingReturnType() const
Definition arguments.h:114
ArgumentList::size
size_t size() const
Definition arguments.h:100
ArgumentList::constSpecifier
bool constSpecifier() const
Definition arguments.h:111
ArgumentList::empty
bool empty() const
Definition arguments.h:99
ArgumentList::begin
iterator begin()
Definition arguments.h:93
ArgumentList::volatileSpecifier
bool volatileSpecifier() const
Definition arguments.h:112
ClassDef
A abstract class representing of a compound symbol.
Definition classdef.h:104
ClassDef::compoundTypeString
virtual QCString compoundTypeString() const =0
Returns the type of compound as a string.
ClassDef::isBaseClass
virtual int isBaseClass(const ClassDef *bcd, bool followInstances, const QCString &templSpec=QCString()) const =0
Returns TRUE iff bcd is a direct or indirect base class of this class.
ClassDef::getTemplateParameterLists
virtual ArgumentLists getTemplateParameterLists() const =0
Returns the template parameter lists that form the template declaration of this class.
ClassDef::isObjectiveC
virtual bool isObjectiveC() const =0
Returns TRUE if this class is implemented in Objective-C.
ClassDef::isSimple
virtual bool isSimple() const =0
ClassDef::categoryOf
virtual ClassDef * categoryOf() const =0
Returns the class of which this is a category (Objective-C only).
ClassDef::writeDeclaration
virtual void writeDeclaration(OutputList &ol, const MemberDef *md, bool inGroup, int indentLevel, const ClassDef *inheritedFrom, const QCString &inheritId) const =0
ClassDef::Interface
@ Interface
Definition classdef.h:112
ClassDef::compoundType
virtual CompoundType compoundType() const =0
Returns the type of compound this is, i.e. class/struct/union/...
DefinitionAliasMixin< MemberDef >::getAlias
const Definition * getAlias() const
Definition definitionimpl.h:453
DefinitionAliasMixin< MemberDef >::getScope
const Definition * getScope() const
Definition definitionimpl.h:454
DefinitionAliasMixin< MemberDef >::DefinitionAliasMixin
DefinitionAliasMixin(const Definition *scope, const Definition *alias)
Definition definitionimpl.h:337
Definition
The common base class of all entity definitions found in the sources.
Definition definition.h:77
Definition::docFile
virtual QCString docFile() const =0
Definition::localName
virtual const QCString & localName() const =0
Definition::getEndBodyLine
virtual int getEndBodyLine() const =0
Definition::getLanguage
virtual SrcLangExt getLanguage() const =0
Returns the programming language this definition was written in.
Definition::docLine
virtual int docLine() const =0
Definition::getDefFileName
virtual QCString getDefFileName() const =0
Definition::isLinkable
virtual bool isLinkable() const =0
Definition::getDefLine
virtual int getDefLine() const =0
Definition::definitionType
virtual DefType definitionType() const =0
Definition::anchor
virtual QCString anchor() const =0
Definition::inbodyLine
virtual int inbodyLine() const =0
Definition::getBodyDef
virtual const FileDef * getBodyDef() const =0
Definition::briefLine
virtual int briefLine() const =0
Definition::hasDocumentation
virtual bool hasDocumentation() const =0
Definition::isLinkableInProject
virtual bool isLinkableInProject() const =0
Definition::briefDescription
virtual QCString briefDescription(bool abbreviate=FALSE) const =0
Definition::hasUserDocumentation
virtual bool hasUserDocumentation() const =0
Definition::isAnonymous
virtual bool isAnonymous() const =0
Definition::getReference
virtual QCString getReference() const =0
Definition::documentation
virtual QCString documentation() const =0
Definition::qualifiedName
virtual QCString qualifiedName() const =0
Definition::displayName
virtual QCString displayName(bool includeScope=TRUE) const =0
Definition::briefFile
virtual QCString briefFile() const =0
Definition::codeSymbolType
virtual CodeSymbolType codeSymbolType() const =0
Definition::getOutputFileBase
virtual QCString getOutputFileBase() const =0
Definition::getOuterScope
virtual Definition * getOuterScope() const =0
Definition::getStartBodyLine
virtual int getStartBodyLine() const =0
Definition::isReference
virtual bool isReference() const =0
Definition::inbodyDocumentation
virtual QCString inbodyDocumentation() const =0
Definition::inbodyFile
virtual QCString inbodyFile() const =0
Definition::name
virtual const QCString & name() const =0
DefinitionMixin::isReference
bool isReference() const override
Definition definitionimpl.h:198
DefinitionMixin< MemberDefMutable >::name
const QCString & name() const override
Definition definitionimpl.h:169
DefinitionMixin< MemberDefMutable >::writeSourceDef
void writeSourceDef(OutputList &ol) const override
Definition definitionimpl.h:264
DefinitionMixin::hasUserDocumentation
bool hasUserDocumentation() const override
Definition definitionimpl.h:191
DefinitionMixin< MemberDefMutable >::inbodyFile
QCString inbodyFile() const override
Definition definitionimpl.h:183
DefinitionMixin< MemberDefMutable >::getDefFileName
QCString getDefFileName() const override
Definition definitionimpl.h:186
DefinitionMixin< MemberDefMutable >::writeSourceRefs
void writeSourceRefs(OutputList &ol, const QCString &scopeName) const override
Definition definitionimpl.h:272
DefinitionMixin< MemberDefMutable >::hasBriefDescription
bool hasBriefDescription() const override
Definition definitionimpl.h:215
DefinitionMixin< MemberDefMutable >::docFile
QCString docFile() const override
Definition definitionimpl.h:178
DefinitionMixin< MemberDefMutable >::getDefFileExtension
QCString getDefFileExtension() const override
Definition definitionimpl.h:187
DefinitionMixin< MemberDefMutable >::hasRequirementRefs
bool hasRequirementRefs() const override
Definition definitionimpl.h:276
DefinitionMixin< MemberDefMutable >::briefFile
QCString briefFile() const override
Definition definitionimpl.h:185
DefinitionMixin::qualifiedName
QCString qualifiedName() const override
Definition definitionimpl.h:172
DefinitionMixin< MemberDefMutable >::setOuterScope
void setOuterScope(Definition *def) override
Definition definitionimpl.h:254
DefinitionMixin::setDocumentation
void setDocumentation(const QCString &doc, const QCString &docFile, int docLine, bool stripWhiteSpace=TRUE) override
Definition definitionimpl.h:224
DefinitionMixin< MemberDefMutable >::setReference
void setReference(const QCString &r) override
Definition definitionimpl.h:230
DefinitionMixin< MemberDefMutable >::writeRequirementRefs
void writeRequirementRefs(OutputList &ol) const override
Definition definitionimpl.h:278
DefinitionMixin< MemberDefMutable >::getSourceFileBase
QCString getSourceFileBase() const override
Definition definitionimpl.h:174
DefinitionMixin< MemberDefMutable >::xrefListItems
const RefItemVector & xrefListItems() const override
Definition definitionimpl.h:207
DefinitionMixin::briefDescription
QCString briefDescription(bool abbreviate=FALSE) const override
Definition definitionimpl.h:179
DefinitionMixin< MemberDefMutable >::hasSourceReffedBy
bool hasSourceReffedBy() const override
Definition definitionimpl.h:270
DefinitionMixin::setBriefDescription
void setBriefDescription(const QCString &brief, const QCString &briefFile, int briefLine) override
Definition definitionimpl.h:226
DefinitionMixin< MemberDefMutable >::writeSourceReffedBy
void writeSourceReffedBy(OutputList &ol, const QCString &scopeName) const override
Definition definitionimpl.h:274
DefinitionMixin< MemberDefMutable >::getOuterScope
Definition * getOuterScope() const override
Definition definitionimpl.h:210
DefinitionMixin::setInbodyDocumentation
void setInbodyDocumentation(const QCString &doc, const QCString &docFile, int docLine) override
Definition definitionimpl.h:228
DefinitionMixin::getReference
QCString getReference() const override
Definition definitionimpl.h:197
DefinitionMixin< MemberDefMutable >::DefinitionMixin
DefinitionMixin(const QCString &defFileName, int defLine, int defColumn, const QCString &name, const char *b=nullptr, const char *d=nullptr, bool isSymbol=TRUE)
Definition definitionimpl.h:156
DefinitionMixin< MemberDefMutable >::localName
const QCString & localName() const override
Definition definitionimpl.h:171
DefinitionMixin< MemberDefMutable >::writeInlineCode
void writeInlineCode(OutputList &ol, const QCString &scopeName) const override
Definition definitionimpl.h:266
DefinitionMixin< MemberDefMutable >::getBodyDef
const FileDef * getBodyDef() const override
Definition definitionimpl.h:203
DefinitionMixin< MemberDefMutable >::setDefFile
void setDefFile(const QCString &df, int defLine, int defColumn) override
Definition definitionimpl.h:222
DefinitionMixin< MemberDefMutable >::inbodyDocumentation
QCString inbodyDocumentation() const override
Definition definitionimpl.h:182
DefinitionMixin::setHidden
void setHidden(bool b) override
Definition definitionimpl.h:256
DefinitionMixin::documentation
QCString documentation() const override
Definition definitionimpl.h:176
DefinitionMixin< MemberDefMutable >::writeDocAnchorsToTagFile
void writeDocAnchorsToTagFile(TextStream &fs) const override
Definition definitionimpl.h:294
DefinitionMixin::hasDocumentation
bool hasDocumentation() const override
Definition definitionimpl.h:190
DefinitionMixin< MemberDefMutable >::getLanguage
SrcLangExt getLanguage() const override
Definition definitionimpl.h:204
DefinitionMutable::setBodySegment
virtual void setBodySegment(int defLine, int bls, int ble)=0
DefinitionMutable::setDocumentation
virtual void setDocumentation(const QCString &d, const QCString &docFile, int docLine, bool stripWhiteSpace=TRUE)=0
DefinitionMutable::addSourceReferences
virtual void addSourceReferences(MemberDef *d, const QCString &sourceRefName)=0
DefinitionMutable::setInbodyDocumentation
virtual void setInbodyDocumentation(const QCString &d, const QCString &docFile, int docLine)=0
DefinitionMutable::mergeRefItems
virtual void mergeRefItems(Definition *d)=0
DefinitionMutable::setBodyDef
virtual void setBodyDef(const FileDef *fd)=0
DefinitionMutable::setBriefDescription
virtual void setBriefDescription(const QCString &b, const QCString &briefFile, int briefLine)=0
DefinitionMutable::addSourceReferencedBy
virtual void addSourceReferencedBy(MemberDef *d, const QCString &sourceRefName)=0
DotCallGraph
Representation of an call graph.
Definition dotcallgraph.h:27
DotCallGraph::numNodes
int numNodes() const
Definition dotcallgraph.cpp:207
DotCallGraph::isTooBig
bool isTooBig() const
Definition dotcallgraph.cpp:202
DotCallGraph::isTrivial
bool isTrivial() const
Definition dotcallgraph.cpp:197
Doxygen::suppressDocWarnings
static bool suppressDocWarnings
Definition doxygen.h:130
Doxygen::parseSourcesNeeded
static bool parseSourcesNeeded
Definition doxygen.h:123
Doxygen::parserManager
static ParserManager * parserManager
Definition doxygen.h:129
Doxygen::globalScope
static NamespaceDefMutable * globalScope
Definition doxygen.h:121
FileDef
A model of a file symbol.
Definition filedef.h:99
FileDef::absFilePath
virtual QCString absFilePath() const =0
GroupDef
A model of a group of symbols.
Definition groupdef.h:52
MemberDefAliasImpl::hasEnumValues
bool hasEnumValues() const override
Definition memberdef.cpp:891
MemberDefAliasImpl::isConstEval
bool isConstEval() const override
Definition memberdef.cpp:799
MemberDefAliasImpl::getCachedTypedefVal
const ClassDef * getCachedTypedefVal() const override
Definition memberdef.cpp:903
MemberDefAliasImpl::getNamespaceDef
NamespaceDef * getNamespaceDef() override
Definition memberdef.cpp:608
MemberDefAliasImpl::getNamespaceDef
const NamespaceDef * getNamespaceDef() const override
Definition memberdef.cpp:606
MemberDefAliasImpl::hasExamples
bool hasExamples() const override
Definition memberdef.cpp:853
MemberDefAliasImpl::getGroupDef
GroupDef * getGroupDef() override
Definition memberdef.cpp:619
MemberDefAliasImpl::getDeclFileName
QCString getDeclFileName() const override
Definition memberdef.cpp:937
MemberDefAliasImpl::argsString
QCString argsString() const override
Definition memberdef.cpp:572
MemberDefAliasImpl::isSettable
bool isSettable() const override
Definition memberdef.cpp:691
MemberDefAliasImpl::isConstrained
bool isConstrained() const override
Definition memberdef.cpp:759
MemberDefAliasImpl::getGroupHasDocs
bool getGroupHasDocs() const override
Definition memberdef.cpp:627
MemberDefAliasImpl::getClassDef
const ClassDef * getClassDef() const override
Definition memberdef.cpp:593
MemberDefAliasImpl::inheritsDocsFrom
const MemberDef * inheritsDocsFrom() const override
Definition memberdef.cpp:913
MemberDefAliasImpl::hasCallerGraph
bool hasCallerGraph() const override
Definition memberdef.cpp:879
MemberDefAliasImpl::enumBaseType
QCString enumBaseType() const override
Definition memberdef.cpp:851
MemberDefAliasImpl::isConstInit
bool isConstInit() const override
Definition memberdef.cpp:801
MemberDefAliasImpl::isFinal
bool isFinal() const override
Definition memberdef.cpp:707
MemberDefAliasImpl::reimplements
const MemberDef * reimplements() const override
Definition memberdef.cpp:833
MemberDefAliasImpl::isOptional
bool isOptional() const override
Definition memberdef.cpp:715
MemberDefAliasImpl::getOutputFileBase
QCString getOutputFileBase() const override
Definition memberdef.cpp:560
MemberDefAliasImpl::isTypeAlias
bool isTypeAlias() const override
Definition memberdef.cpp:743
MemberDefAliasImpl::isRequired
bool isRequired() const override
Definition memberdef.cpp:717
MemberDefAliasImpl::isRemovable
bool isRemovable() const override
Definition memberdef.cpp:703
MemberDefAliasImpl::setMemberGroup
void setMemberGroup(MemberGroup *grp) override
Definition memberdef.cpp:953
MemberDefAliasImpl::isDeleted
bool isDeleted() const override
Definition memberdef.cpp:821
MemberDefAliasImpl::isPrivateGettable
bool isPrivateGettable() const override
Definition memberdef.cpp:687
MemberDefAliasImpl::isSignal
bool isSignal() const override
Definition memberdef.cpp:641
MemberDefAliasImpl::memberDeclaration
MemberDef * memberDeclaration() const override
Definition memberdef.cpp:911
MemberDefAliasImpl::isFriendClass
bool isFriendClass() const override
Definition memberdef.cpp:829
MemberDefAliasImpl::getGroupAlias
const MemberDef * getGroupAlias() const override
Definition memberdef.cpp:915
MemberDefAliasImpl::isStrongEnumValue
bool isStrongEnumValue() const override
Definition memberdef.cpp:789
MemberDefAliasImpl::isAssign
bool isAssign() const override
Definition memberdef.cpp:723
MemberDefAliasImpl::getReadAccessor
QCString getReadAccessor() const override
Definition memberdef.cpp:613
MemberDefAliasImpl::getGroupStartLine
int getGroupStartLine() const override
Definition memberdef.cpp:625
MemberDefAliasImpl::deepCopy
std::unique_ptr< MemberDef > deepCopy() const override
Definition memberdef.cpp:551
MemberDefAliasImpl::isUNOProperty
bool isUNOProperty() const override
Definition memberdef.cpp:753
MemberDefAliasImpl::warnIfUndocumented
void warnIfUndocumented() const override
Definition memberdef.cpp:950
MemberDefAliasImpl::hasUserDocumentation
bool hasUserDocumentation() const override
Definition memberdef.cpp:819
MemberDefAliasImpl::isSliceLocal
bool isSliceLocal() const override
Definition memberdef.cpp:793
MemberDefAliasImpl::definitionTemplateParameterLists
const ArgumentLists & definitionTemplateParameterLists() const override
Definition memberdef.cpp:865
MemberDefAliasImpl::isPublished
bool isPublished() const override
Definition memberdef.cpp:769
MemberDefAliasImpl::isSequence
bool isSequence() const override
Definition memberdef.cpp:653
MemberDefAliasImpl::isDictionary
bool isDictionary() const override
Definition memberdef.cpp:655
MemberDefAliasImpl::isVariable
bool isVariable() const override
Definition memberdef.cpp:645
MemberDefAliasImpl::getFileDef
FileDef * getFileDef() override
Definition memberdef.cpp:600
MemberDefAliasImpl::getClassDefOfAnonymousType
ClassDef * getClassDefOfAnonymousType() const override
Definition memberdef.cpp:899
MemberDefAliasImpl::getCachedResolvedTypedef
QCString getCachedResolvedTypedef() const override
Definition memberdef.cpp:907
MemberDefAliasImpl::templateMaster
const MemberDef * templateMaster() const override
Definition memberdef.cpp:895
MemberDefAliasImpl::warnIfUndocumentedParams
void warnIfUndocumentedParams() const override
Definition memberdef.cpp:951
MemberDefAliasImpl::isExternal
bool isExternal() const override
Definition memberdef.cpp:741
MemberDefAliasImpl::isProperty
bool isProperty() const override
Definition memberdef.cpp:667
MemberDefAliasImpl::isWritable
bool isWritable() const override
Definition memberdef.cpp:699
MemberDefAliasImpl::isDocumentedFriendClass
bool isDocumentedFriendClass() const override
Definition memberdef.cpp:831
MemberDefAliasImpl::redefineCount
int redefineCount() const override
Definition memberdef.cpp:947
MemberDefAliasImpl::isConstExpr
bool isConstExpr() const override
Definition memberdef.cpp:797
MemberDefAliasImpl::initializerLines
int initializerLines() const override
Definition memberdef.cpp:582
MemberDefAliasImpl::isMaybeVoid
bool isMaybeVoid() const override
Definition memberdef.cpp:763
MemberDefAliasImpl::getMemberGroupId
int getMemberGroupId() const override
Definition memberdef.cpp:869
MemberDefAliasImpl::isInitonly
bool isInitonly() const override
Definition memberdef.cpp:713
MemberDefAliasImpl::getExamples
const ExampleList & getExamples() const override
Definition memberdef.cpp:855
MemberDefAliasImpl::hasOneLineInitializer
bool hasOneLineInitializer() const override
Definition memberdef.cpp:783
MemberDefAliasImpl::isProtectedGettable
bool isProtectedGettable() const override
Definition memberdef.cpp:689
MemberDefAliasImpl::hasDocumentation
bool hasDocumentation() const override
Definition memberdef.cpp:817
MemberDefAliasImpl::livesInsideEnum
bool livesInsideEnum() const override
Definition memberdef.cpp:791
MemberDefAliasImpl::declaration
QCString declaration() const override
Definition memberdef.cpp:566
MemberDefAliasImpl::hasCallGraph
bool hasCallGraph() const override
Definition memberdef.cpp:877
MemberDefAliasImpl::isCopy
bool isCopy() const override
Definition memberdef.cpp:721
MemberDefAliasImpl::getDeclLine
int getDeclLine() const override
Definition memberdef.cpp:939
MemberDefAliasImpl::isEnumerate
bool isEnumerate() const override
Definition memberdef.cpp:647
MemberDefAliasImpl::writeLink
void writeLink(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool onlyText=FALSE) const override
Definition memberdef.cpp:969
MemberDefAliasImpl::initializer
const QCString & initializer() const override
Definition memberdef.cpp:580
MemberDefAliasImpl::isReference
bool isReference() const override
Definition memberdef.cpp:935
MemberDefAliasImpl::getMemberSpecifiers
TypeSpecifier getMemberSpecifiers() const override
Definition memberdef.cpp:584
MemberDefAliasImpl::getReference
QCString getReference() const override
Definition memberdef.cpp:562
MemberDefAliasImpl::isThreadLocal
bool isThreadLocal() const override
Definition memberdef.cpp:683
MemberDefAliasImpl::hasMultiLineInitializer
bool hasMultiLineInitializer() const override
Definition memberdef.cpp:785
MemberDefAliasImpl::getCachedTypedefTemplSpec
QCString getCachedTypedefTemplSpec() const override
Definition memberdef.cpp:905
MemberDefAliasImpl::isDocsForDefinition
bool isDocsForDefinition() const override
Definition memberdef.cpp:845
MemberDefAliasImpl::getGroupPri
Grouping::GroupPri_t getGroupPri() const override
Definition memberdef.cpp:621
MemberDefAliasImpl::isTypedefValCached
bool isTypedefValCached() const override
Definition memberdef.cpp:901
MemberDefAliasImpl::accessorClass
const ClassDef * accessorClass() const override
Definition memberdef.cpp:611
MemberDefAliasImpl::isRaisable
bool isRaisable() const override
Definition memberdef.cpp:705
MemberDefAliasImpl::isUnretained
bool isUnretained() const override
Definition memberdef.cpp:733
MemberDefAliasImpl::isGettable
bool isGettable() const override
Definition memberdef.cpp:685
MemberDefAliasImpl::enumFieldList
const MemberVector & enumFieldList() const override
Definition memberdef.cpp:849
MemberDefAliasImpl::isObjCProperty
bool isObjCProperty() const override
Definition memberdef.cpp:775
MemberDefAliasImpl::getDeclColumn
int getDeclColumn() const override
Definition memberdef.cpp:941
MemberDefAliasImpl::declArgumentList
const ArgumentList & declArgumentList() const override
Definition memberdef.cpp:861
MemberDefAliasImpl::isCallable
bool isCallable() const override
Definition memberdef.cpp:787
MemberDefAliasImpl::isDefine
bool isDefine() const override
Definition memberdef.cpp:661
MemberDefAliasImpl::isLinkableInProject
bool isLinkableInProject() const override
Definition memberdef.cpp:813
MemberDefAliasImpl::hasDetailedDescription
bool hasDetailedDescription() const override
Definition memberdef.cpp:827
MemberDefAliasImpl::isFriendToHide
bool isFriendToHide() const override
Definition memberdef.cpp:805
MemberDefAliasImpl::excpString
QCString excpString() const override
Definition memberdef.cpp:574
MemberDefAliasImpl::getDeclType
QCString getDeclType() const override
Definition memberdef.cpp:923
MemberDefAliasImpl::briefDescription
QCString briefDescription(bool) const override
Definition memberdef.cpp:931
MemberDefAliasImpl::objCMethodName
QCString objCMethodName(bool localLink, bool showStatic) const override
Definition memberdef.cpp:631
MemberDefAliasImpl::getGroupDef
const GroupDef * getGroupDef() const override
Definition memberdef.cpp:617
MemberDefAliasImpl::isDestructor
bool isDestructor() const override
Definition memberdef.cpp:781
MemberDefAliasImpl::isNoDiscard
bool isNoDiscard() const override
Definition memberdef.cpp:795
MemberDefAliasImpl::hasDocumentedEnumValues
bool hasDocumentedEnumValues() const override
Definition memberdef.cpp:841
MemberDefAliasImpl::isBound
bool isBound() const override
Definition memberdef.cpp:757
MemberDefAliasImpl::detectUndocumentedParams
void detectUndocumentedParams(bool, bool) const override
Definition memberdef.cpp:952
MemberDefAliasImpl::fromAnonymousScope
bool fromAnonymousScope() const override
Definition memberdef.cpp:873
MemberDefAliasImpl::isFunctionPtr
bool isFunctionPtr() const override
Definition memberdef.cpp:659
MemberDefAliasImpl::getLabels
StringVector getLabels(const Definition *container) const override
Definition memberdef.cpp:925
MemberDefAliasImpl::memberTypeName
QCString memberTypeName() const override
Definition memberdef.cpp:639
MemberDefAliasImpl::createTemplateInstanceMember
std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const override
Definition memberdef.cpp:954
MemberDefAliasImpl::isAddable
bool isAddable() const override
Definition memberdef.cpp:701
MemberDefAliasImpl::getScopeString
QCString getScopeString() const override
Definition memberdef.cpp:897
MemberDefAliasImpl::getGroupFileName
QCString getGroupFileName() const override
Definition memberdef.cpp:623
MemberDefAliasImpl::extraTypeChars
QCString extraTypeChars() const override
Definition memberdef.cpp:578
MemberDefAliasImpl::argumentList
const ArgumentList & argumentList() const override
Definition memberdef.cpp:859
MemberDefAliasImpl::typeConstraints
const ArgumentList & typeConstraints() const override
Definition memberdef.cpp:927
MemberDefAliasImpl::virtualness
Specifier virtualness(int) const override
Definition memberdef.cpp:635
MemberDefAliasImpl::isFunctionOrSignalSlot
bool isFunctionOrSignalSlot() const override
Definition memberdef.cpp:809
MemberDefAliasImpl::isDefault
bool isDefault() const override
Definition memberdef.cpp:745
MemberDefAliasImpl::isPrototype
bool isPrototype() const override
Definition memberdef.cpp:857
MemberDefAliasImpl::isAttribute
bool isAttribute() const override
Definition memberdef.cpp:751
MemberDefAliasImpl::memberDefinition
MemberDef * memberDefinition() const override
Definition memberdef.cpp:909
MemberDefAliasImpl::isTypedef
bool isTypedef() const override
Definition memberdef.cpp:651
MemberDefAliasImpl::isNoExcept
bool isNoExcept() const override
Definition memberdef.cpp:749
MemberDefAliasImpl::displayDefinition
QCString displayDefinition() const override
Definition memberdef.cpp:590
MemberDefAliasImpl::isInline
bool isInline() const override
Definition memberdef.cpp:677
MemberDefAliasImpl::isRelatedOrFriend
bool isRelatedOrFriend() const override
Definition memberdef.cpp:811
MemberDefAliasImpl::hasReferencesRelation
bool hasReferencesRelation() const override
Definition memberdef.cpp:881
MemberDefAliasImpl::isStrong
bool isStrong() const override
Definition memberdef.cpp:729
MemberDefAliasImpl::getMdAlias
const MemberDef * getMdAlias() const
Definition memberdef.cpp:546
MemberDefAliasImpl::isObjCMethod
bool isObjCMethod() const override
Definition memberdef.cpp:773
MemberDefAliasImpl::isAbstract
bool isAbstract() const override
Definition memberdef.cpp:709
MemberDefAliasImpl::isStatic
bool isStatic() const override
Definition memberdef.cpp:675
MemberDefAliasImpl::isPrivateSettable
bool isPrivateSettable() const override
Definition memberdef.cpp:693
MemberDefAliasImpl::isSealed
bool isSealed() const override
Definition memberdef.cpp:737
MemberDefAliasImpl::isRelated
bool isRelated() const override
Definition memberdef.cpp:671
MemberDefAliasImpl::getMdAlias
MemberDef * getMdAlias()
Definition memberdef.cpp:547
MemberDefAliasImpl::isOverride
bool isOverride() const override
Definition memberdef.cpp:711
MemberDefAliasImpl::isForeign
bool isForeign() const override
Definition memberdef.cpp:673
MemberDefAliasImpl::isImplementation
bool isImplementation() const override
Definition memberdef.cpp:739
MemberDefAliasImpl::anchor
QCString anchor() const override
Definition memberdef.cpp:564
MemberDefAliasImpl::reimplementedBy
const MemberVector & reimplementedBy() const override
Definition memberdef.cpp:835
MemberDefAliasImpl::getVhdlSpecifiers
VhdlSpecifier getVhdlSpecifiers() const override
Definition memberdef.cpp:586
MemberDefAliasImpl::isMaybeDefault
bool isMaybeDefault() const override
Definition memberdef.cpp:765
MemberDefAliasImpl::memberType
MemberType memberType() const override
Definition memberdef.cpp:637
MemberDefAliasImpl::isLinkable
bool isLinkable() const override
Definition memberdef.cpp:815
MemberDefAliasImpl::isProtectedSettable
bool isProtectedSettable() const override
Definition memberdef.cpp:695
MemberDefAliasImpl::isReadonly
bool isReadonly() const override
Definition memberdef.cpp:755
MemberDefAliasImpl::categoryRelation
const MemberDef * categoryRelation() const override
Definition memberdef.cpp:919
MemberDefAliasImpl::getClassDef
ClassDef * getClassDef() override
Definition memberdef.cpp:595
MemberDefAliasImpl::MemberDefAliasImpl
MemberDefAliasImpl(const Definition *newScope, const MemberDef *md)
Definition memberdef.cpp:539
MemberDefAliasImpl::getEnumScope
const MemberDef * getEnumScope() const override
Definition memberdef.cpp:847
MemberDefAliasImpl::protection
Protection protection() const override
Definition memberdef.cpp:633
MemberDefAliasImpl::isSlot
bool isSlot() const override
Definition memberdef.cpp:643
MemberDefAliasImpl::name
const QCString & name() const override
Definition memberdef.cpp:556
MemberDefAliasImpl::isDelete
bool isDelete() const override
Definition memberdef.cpp:747
MemberDefAliasImpl::isReadable
bool isReadable() const override
Definition memberdef.cpp:697
MemberDefAliasImpl::isEvent
bool isEvent() const override
Definition memberdef.cpp:669
MemberDefAliasImpl::definition
QCString definition() const override
Definition memberdef.cpp:568
MemberDefAliasImpl::isNonAtomic
bool isNonAtomic() const override
Definition memberdef.cpp:719
MemberDefAliasImpl::getWriteAccessor
QCString getWriteAccessor() const override
Definition memberdef.cpp:615
MemberDefAliasImpl::bitfieldString
QCString bitfieldString() const override
Definition memberdef.cpp:576
MemberDefAliasImpl::definitionType
DefType definitionType() const override
Definition memberdef.cpp:544
MemberDefAliasImpl::isReimplementedBy
bool isReimplementedBy(const ClassDef *cd) const override
Definition memberdef.cpp:837
MemberDefAliasImpl::isDCOP
bool isDCOP() const override
Definition memberdef.cpp:665
MemberDefAliasImpl::writeEnumDeclaration
void writeEnumDeclaration(OutputList &typeDecl, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod) const override
Definition memberdef.cpp:964
MemberDefAliasImpl::isDocTransferDone
bool isDocTransferDone() const override
Definition memberdef.cpp:887
MemberDefAliasImpl::isDetailedSectionVisible
bool isDetailedSectionVisible(MemberListContainer container) const override
Definition memberdef.cpp:825
MemberDefAliasImpl::isNotFriend
bool isNotFriend() const override
Definition memberdef.cpp:807
MemberDefAliasImpl::writeDeclaration
void writeDeclaration(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool inGroup, int indentLevel, const ClassDef *inheritFrom=nullptr, const QCString &inheritId=QCString()) const override
Definition memberdef.cpp:958
MemberDefAliasImpl::getSectionList
const MemberList * getSectionList(const Definition *container) const override
Definition memberdef.cpp:588
MemberDefAliasImpl::isTemplateSpecialization
bool isTemplateSpecialization() const override
Definition memberdef.cpp:771
MemberDefAliasImpl::typeString
QCString typeString() const override
Definition memberdef.cpp:570
MemberDefAliasImpl::getModuleDef
const ModuleDef * getModuleDef() const override
Definition memberdef.cpp:603
MemberDefAliasImpl::isExplicit
bool isExplicit() const override
Definition memberdef.cpp:679
MemberDefAliasImpl::codeSymbolType
CodeSymbolType codeSymbolType() const override
Definition memberdef.cpp:558
MemberDefAliasImpl::fromAnonymousMember
MemberDef * fromAnonymousMember() const override
Definition memberdef.cpp:875
MemberDefAliasImpl::isConstructor
bool isConstructor() const override
Definition memberdef.cpp:779
MemberDefAliasImpl::isTransient
bool isTransient() const override
Definition memberdef.cpp:761
MemberDefAliasImpl::numberOfFlowKeyWords
int numberOfFlowKeyWords() const override
Definition memberdef.cpp:803
MemberDefAliasImpl::isFriend
bool isFriend() const override
Definition memberdef.cpp:663
MemberDefAliasImpl::isWeak
bool isWeak() const override
Definition memberdef.cpp:727
MemberDefAliasImpl::isMutable
bool isMutable() const override
Definition memberdef.cpp:681
MemberDefAliasImpl::requiresClause
QCString requiresClause() const override
Definition memberdef.cpp:943
MemberDefAliasImpl::resolveAlias
MemberDef * resolveAlias() override
Definition memberdef.cpp:548
MemberDefAliasImpl::getFileDef
const FileDef * getFileDef() const override
Definition memberdef.cpp:598
MemberDefAliasImpl::fieldType
QCString fieldType() const override
Definition memberdef.cpp:933
MemberDefAliasImpl::formalTemplateArguments
std::optional< ArgumentList > formalTemplateArguments() const override
Definition memberdef.cpp:867
MemberDefAliasImpl::resolveAlias
const MemberDef * resolveAlias() const override
Definition memberdef.cpp:549
MemberDefAliasImpl::isEnumValue
bool isEnumValue() const override
Definition memberdef.cpp:649
MemberDefAliasImpl::isNew
bool isNew() const override
Definition memberdef.cpp:735
MemberDefAliasImpl::getAnonymousEnumType
const MemberDef * getAnonymousEnumType() const override
Definition memberdef.cpp:843
MemberDefAliasImpl::isMaybeAmbiguous
bool isMaybeAmbiguous() const override
Definition memberdef.cpp:767
MemberDefAliasImpl::hasReferencedByRelation
bool hasReferencedByRelation() const override
Definition memberdef.cpp:883
MemberDefAliasImpl::isCSharpProperty
bool isCSharpProperty() const override
Definition memberdef.cpp:777
MemberDefAliasImpl::hasInlineSource
bool hasInlineSource() const override
Definition memberdef.cpp:885
MemberDefAliasImpl::category
ClassDef * category() const override
Definition memberdef.cpp:917
MemberDefAliasImpl::moveTo
void moveTo(Definition *) override
Definition memberdef.cpp:554
MemberDefAliasImpl::getMemberGroup
MemberGroup * getMemberGroup() const override
Definition memberdef.cpp:871
MemberDefAliasImpl::m_memberGroup
MemberGroup * m_memberGroup
Definition memberdef.cpp:976
MemberDefAliasImpl::isFunction
bool isFunction() const override
Definition memberdef.cpp:657
MemberDefAliasImpl::displayName
QCString displayName(bool b=TRUE) const override
Definition memberdef.cpp:921
MemberDefAliasImpl::visibleInIndex
bool visibleInIndex() const override
Definition memberdef.cpp:945
MemberDefAliasImpl::sourceRefName
QCString sourceRefName() const override
Definition memberdef.cpp:889
MemberDefAliasImpl::relatedAlso
ClassDef * relatedAlso() const override
Definition memberdef.cpp:839
MemberDefAliasImpl::isRetain
bool isRetain() const override
Definition memberdef.cpp:725
MemberDefAliasImpl::isEnumStruct
bool isEnumStruct() const override
Definition memberdef.cpp:731
MemberDefAliasImpl::documentation
QCString documentation() const override
Definition memberdef.cpp:929
MemberDefAliasImpl::isBriefSectionVisible
bool isBriefSectionVisible() const override
Definition memberdef.cpp:823
MemberDefAliasImpl::templateArguments
const ArgumentList & templateArguments() const override
Definition memberdef.cpp:863
MemberDefAliasImpl::~MemberDefAliasImpl
~MemberDefAliasImpl() override
Definition memberdef.cpp:541
MemberDefAliasImpl::getQualifiers
StringVector getQualifiers() const override
Definition memberdef.cpp:893
MemberDefAliasImpl::qualifiedName
QCString qualifiedName() const override
Definition memberdef.cpp:629
MemberDef
A model of a class/file/namespace member symbol.
Definition memberdef.h:48
MemberDef::typeString
virtual QCString typeString() const =0
MemberDef::isConstExpr
virtual bool isConstExpr() const =0
MemberDef::getGroupHasDocs
virtual bool getGroupHasDocs() const =0
MemberDef::getAnonymousEnumType
virtual const MemberDef * getAnonymousEnumType() const =0
MemberDef::isConstEval
virtual bool isConstEval() const =0
MemberDef::isInitonly
virtual bool isInitonly() const =0
MemberDef::isSignal
virtual bool isSignal() const =0
MemberDef::isNoExcept
virtual bool isNoExcept() const =0
MemberDef::requiresClause
virtual QCString requiresClause() const =0
MemberDef::isDestructor
virtual bool isDestructor() const =0
MemberDef::hasDetailedDescription
virtual bool hasDetailedDescription() const =0
MemberDef::isAssign
virtual bool isAssign() const =0
MemberDef::isExplicit
virtual bool isExplicit() const =0
MemberDef::memberDefinition
virtual MemberDef * memberDefinition() const =0
MemberDef::isNew
virtual bool isNew() const =0
MemberDef::declaration
virtual QCString declaration() const =0
MemberDef::getCachedResolvedTypedef
virtual QCString getCachedResolvedTypedef() const =0
MemberDef::isObjCMethod
virtual bool isObjCMethod() const =0
MemberDef::hasDocumentedEnumValues
virtual bool hasDocumentedEnumValues() const =0
MemberDef::memberDeclaration
virtual MemberDef * memberDeclaration() const =0
MemberDef::isMaybeVoid
virtual bool isMaybeVoid() const =0
MemberDef::isConstructor
virtual bool isConstructor() const =0
MemberDef::isFriend
virtual bool isFriend() const =0
MemberDef::writeEnumDeclaration
virtual void writeEnumDeclaration(OutputList &typeDecl, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod) const =0
MemberDef::accessorClass
virtual const ClassDef * accessorClass() const =0
MemberDef::isForeign
virtual bool isForeign() const =0
MemberDef::isSealed
virtual bool isSealed() const =0
MemberDef::definition
virtual QCString definition() const =0
MemberDef::hasExamples
virtual bool hasExamples() const =0
MemberDef::enumBaseType
virtual QCString enumBaseType() const =0
MemberDef::isDelete
virtual bool isDelete() const =0
MemberDef::writeDeclaration
virtual void writeDeclaration(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *md, bool inGroup, int indentLevel=0, const ClassDef *inheritFrom=nullptr, const QCString &inheritId=QCString()) const =0
MemberDef::numberOfFlowKeyWords
virtual int numberOfFlowKeyWords() const =0
MemberDef::inheritsDocsFrom
virtual const MemberDef * inheritsDocsFrom() const =0
MemberDef::isDefault
virtual bool isDefault() const =0
MemberDef::isRelated
virtual bool isRelated() const =0
MemberDef::isDocumentedFriendClass
virtual bool isDocumentedFriendClass() const =0
MemberDef::isConstInit
virtual bool isConstInit() const =0
MemberDef::fromAnonymousScope
virtual bool fromAnonymousScope() const =0
MemberDef::isDeleted
virtual bool isDeleted() const =0
MemberDef::getCachedTypedefVal
virtual const ClassDef * getCachedTypedefVal() const =0
MemberDef::isRelatedOrFriend
virtual bool isRelatedOrFriend() const =0
MemberDef::fieldType
virtual QCString fieldType() const =0
MemberDef::excpString
virtual QCString excpString() const =0
MemberDef::isSequence
virtual bool isSequence() const =0
MemberDef::isEnumStruct
virtual bool isEnumStruct() const =0
MemberDef::getClassDef
virtual const ClassDef * getClassDef() const =0
MemberDef::visibleInIndex
virtual bool visibleInIndex() const =0
MemberDef::getGroupAlias
virtual const MemberDef * getGroupAlias() const =0
MemberDef::isOverride
virtual bool isOverride() const =0
MemberDef::hasReferencesRelation
virtual bool hasReferencesRelation() const =0
MemberDef::templateArguments
virtual const ArgumentList & templateArguments() const =0
MemberDef::getGroupDef
virtual GroupDef * getGroupDef()=0
MemberDef::isSettable
virtual bool isSettable() const =0
MemberDef::fromAnonymousMember
virtual MemberDef * fromAnonymousMember() const =0
MemberDef::isCSharpProperty
virtual bool isCSharpProperty() const =0
MemberDef::isRetain
virtual bool isRetain() const =0
MemberDef::isAddable
virtual bool isAddable() const =0
MemberDef::isTypedef
virtual bool isTypedef() const =0
MemberDef::category
virtual ClassDef * category() const =0
MemberDef::isSlot
virtual bool isSlot() const =0
MemberDef::enumFieldList
virtual const MemberVector & enumFieldList() const =0
MemberDef::hasCallGraph
virtual bool hasCallGraph() const =0
MemberDef::getFileDef
virtual const FileDef * getFileDef() const =0
MemberDef::isInline
virtual bool isInline() const =0
MemberDef::isEvent
virtual bool isEvent() const =0
MemberDef::argumentList
virtual const ArgumentList & argumentList() const =0
MemberDef::extraTypeChars
virtual QCString extraTypeChars() const =0
MemberDef::isWritable
virtual bool isWritable() const =0
MemberDef::isMaybeAmbiguous
virtual bool isMaybeAmbiguous() const =0
MemberDef::isPrivateGettable
virtual bool isPrivateGettable() const =0
MemberDef::isStrongEnumValue
virtual bool isStrongEnumValue() const =0
MemberDef::getVhdlSpecifiers
virtual VhdlSpecifier getVhdlSpecifiers() const =0
MemberDef::reimplementedBy
virtual const MemberVector & reimplementedBy() const =0
MemberDef::getGroupStartLine
virtual int getGroupStartLine() const =0
MemberDef::isFunction
virtual bool isFunction() const =0
MemberDef::isRequired
virtual bool isRequired() const =0
MemberDef::isAttribute
virtual bool isAttribute() const =0
MemberDef::isExternal
virtual bool isExternal() const =0
MemberDef::sourceRefName
virtual QCString sourceRefName() const =0
MemberDef::isCopy
virtual bool isCopy() const =0
MemberDef::displayDefinition
virtual QCString displayDefinition() const =0
MemberDef::getScopeString
virtual QCString getScopeString() const =0
MemberDef::getMemberGroupId
virtual int getMemberGroupId() const =0
MemberDef::isDictionary
virtual bool isDictionary() const =0
MemberDef::getDeclLine
virtual int getDeclLine() const =0
MemberDef::isTypeAlias
virtual bool isTypeAlias() const =0
MemberDef::getDeclType
virtual QCString getDeclType() const =0
MemberDef::getDeclColumn
virtual int getDeclColumn() const =0
MemberDef::isStatic
virtual bool isStatic() const =0
MemberDef::reimplements
virtual const MemberDef * reimplements() const =0
MemberDef::isMaybeDefault
virtual bool isMaybeDefault() const =0
MemberDef::livesInsideEnum
virtual bool livesInsideEnum() const =0
MemberDef::getWriteAccessor
virtual QCString getWriteAccessor() const =0
MemberDef::hasInlineSource
virtual bool hasInlineSource() const =0
MemberDef::isTemplateSpecialization
virtual bool isTemplateSpecialization() const =0
MemberDef::isPrivateSettable
virtual bool isPrivateSettable() const =0
MemberDef::getQualifiers
virtual StringVector getQualifiers() const =0
MemberDef::getCachedTypedefTemplSpec
virtual QCString getCachedTypedefTemplSpec() const =0
MemberDef::bitfieldString
virtual QCString bitfieldString() const =0
MemberDef::isRaisable
virtual bool isRaisable() const =0
MemberDef::isRemovable
virtual bool isRemovable() const =0
MemberDef::isTypedefValCached
virtual bool isTypedefValCached() const =0
MemberDef::isConstrained
virtual bool isConstrained() const =0
MemberDef::isDocsForDefinition
virtual bool isDocsForDefinition() const =0
MemberDef::isBound
virtual bool isBound() const =0
MemberDef::hasEnumValues
virtual bool hasEnumValues() const =0
MemberDef::isFriendToHide
virtual bool isFriendToHide() const =0
MemberDef::isReimplementedBy
virtual bool isReimplementedBy(const ClassDef *cd) const =0
MemberDef::isNonAtomic
virtual bool isNonAtomic() const =0
MemberDef::getModuleDef
virtual const ModuleDef * getModuleDef() const =0
MemberDef::isThreadLocal
virtual bool isThreadLocal() const =0
MemberDef::isDefine
virtual bool isDefine() const =0
MemberDef::getClassDefOfAnonymousType
virtual ClassDef * getClassDefOfAnonymousType() const =0
MemberDef::getNamespaceDef
virtual const NamespaceDef * getNamespaceDef() const =0
MemberDef::isPublished
virtual bool isPublished() const =0
MemberDef::isFunctionPtr
virtual bool isFunctionPtr() const =0
MemberDef::createTemplateInstanceMember
virtual std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const =0
MemberDef::hasCallerGraph
virtual bool hasCallerGraph() const =0
MemberDef::getGroupPri
virtual Grouping::GroupPri_t getGroupPri() const =0
MemberDef::getDeclFileName
virtual QCString getDeclFileName() const =0
MemberDef::typeConstraints
virtual const ArgumentList & typeConstraints() const =0
MemberDef::isProtectedSettable
virtual bool isProtectedSettable() const =0
MemberDef::isImplementation
virtual bool isImplementation() const =0
MemberDef::isProtectedGettable
virtual bool isProtectedGettable() const =0
MemberDef::objCMethodName
virtual QCString objCMethodName(bool localLink, bool showStatic) const =0
MemberDef::hasOneLineInitializer
virtual bool hasOneLineInitializer() const =0
MemberDef::templateMaster
virtual const MemberDef * templateMaster() const =0
MemberDef::formalTemplateArguments
virtual std::optional< ArgumentList > formalTemplateArguments() const =0
MemberDef::isObjCProperty
virtual bool isObjCProperty() const =0
MemberDef::isTransient
virtual bool isTransient() const =0
MemberDef::getSectionList
virtual const MemberList * getSectionList(const Definition *container) const =0
MemberDef::hasMultiLineInitializer
virtual bool hasMultiLineInitializer() const =0
MemberDef::protection
virtual Protection protection() const =0
MemberDef::getMemberSpecifiers
virtual TypeSpecifier getMemberSpecifiers() const =0
MemberDef::isOptional
virtual bool isOptional() const =0
MemberDef::getReadAccessor
virtual QCString getReadAccessor() const =0
MemberDef::isEnumerate
virtual bool isEnumerate() const =0
MemberDef::isGettable
virtual bool isGettable() const =0
MemberDef::memberType
virtual MemberType memberType() const =0
MemberDef::hasReferencedByRelation
virtual bool hasReferencedByRelation() const =0
MemberDef::isFunctionOrSignalSlot
virtual bool isFunctionOrSignalSlot() const =0
MemberDef::isReadable
virtual bool isReadable() const =0
MemberDef::isWeak
virtual bool isWeak() const =0
MemberDef::isDocTransferDone
virtual bool isDocTransferDone() const =0
MemberDef::isNoDiscard
virtual bool isNoDiscard() const =0
MemberDef::memberTypeName
virtual QCString memberTypeName() const =0
MemberDef::isUnretained
virtual bool isUnretained() const =0
MemberDef::getGroupFileName
virtual QCString getGroupFileName() const =0
MemberDef::writeLink
virtual void writeLink(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *md, bool onlyText=FALSE) const =0
MemberDef::relatedAlso
virtual ClassDef * relatedAlso() const =0
MemberDef::isBriefSectionVisible
virtual bool isBriefSectionVisible() const =0
MemberDef::definitionTemplateParameterLists
virtual const ArgumentLists & definitionTemplateParameterLists() const =0
MemberDef::getLabels
virtual StringVector getLabels(const Definition *container) const =0
MemberDef::isVariable
virtual bool isVariable() const =0
MemberDef::isNotFriend
virtual bool isNotFriend() const =0
MemberDef::isDCOP
virtual bool isDCOP() const =0
MemberDef::isStrong
virtual bool isStrong() const =0
MemberDef::argsString
virtual QCString argsString() const =0
MemberDef::isSliceLocal
virtual bool isSliceLocal() const =0
MemberDef::virtualness
virtual Specifier virtualness(int count=0) const =0
MemberDef::isUNOProperty
virtual bool isUNOProperty() const =0
MemberDef::redefineCount
virtual int redefineCount() const =0
MemberDef::categoryRelation
virtual const MemberDef * categoryRelation() const =0
MemberDef::initializerLines
virtual int initializerLines() const =0
MemberDef::isFinal
virtual bool isFinal() const =0
MemberDef::declArgumentList
virtual const ArgumentList & declArgumentList() const =0
MemberDef::getExamples
virtual const ExampleList & getExamples() const =0
MemberDef::isAbstract
virtual bool isAbstract() const =0
MemberDef::isMutable
virtual bool isMutable() const =0
MemberDef::isFriendClass
virtual bool isFriendClass() const =0
MemberDef::isCallable
virtual bool isCallable() const =0
MemberDef::isDetailedSectionVisible
virtual bool isDetailedSectionVisible(MemberListContainer container) const =0
MemberDef::getEnumScope
virtual const MemberDef * getEnumScope() const =0
MemberDef::isEnumValue
virtual bool isEnumValue() const =0
MemberDef::isPrototype
virtual bool isPrototype() const =0
MemberDef::isProperty
virtual bool isProperty() const =0
MemberDef::initializer
virtual const QCString & initializer() const =0
MemberDefImpl::_hasVisibleCallerGraph
bool _hasVisibleCallerGraph() const
Definition memberdef.cpp:5724
MemberDefImpl::writeDocumentation
void writeDocumentation(const MemberList *ml, int memCount, int memTotal, OutputList &ol, const QCString &scopeName, const Definition *container, bool inGroup, bool showEnumValues=FALSE, bool showInline=FALSE) const override
Definition memberdef.cpp:3478
MemberDefImpl::_writeCallerGraph
void _writeCallerGraph(OutputList &ol) const
Definition memberdef.cpp:2968
MemberDefImpl::insertReimplementedBy
void insertReimplementedBy(MemberDef *md) override
Definition memberdef.cpp:1592
MemberDefImpl::isDCOP
bool isDCOP() const override
Definition memberdef.cpp:5259
MemberDefImpl::sourceRefName
QCString sourceRefName() const override
Definition memberdef.cpp:1653
MemberDefImpl::m_vhdlSpec
VhdlSpecifier m_vhdlSpec
Definition memberdef.cpp:441
MemberDefImpl::isDetailedSectionVisible
bool isDetailedSectionVisible(MemberListContainer container) const override
Definition memberdef.cpp:2790
MemberDefImpl::_isReimplements
bool _isReimplements() const
Definition memberdef.cpp:2990
MemberDefImpl::isFunction
bool isFunction() const override
Definition memberdef.cpp:5239
MemberDefImpl::getDeclColumn
int getDeclColumn() const override
Definition memberdef.cpp:5818
MemberDefImpl::overrideReferencesRelation
void overrideReferencesRelation(bool e) override
Definition memberdef.cpp:4963
MemberDefImpl::reimplements
const MemberDef * reimplements() const override
Definition memberdef.cpp:1608
MemberDefImpl::m_mtype
MemberType m_mtype
Definition memberdef.cpp:442
MemberDefImpl::getMemberGroupId
int getMemberGroupId() const override
Definition memberdef.cpp:5686
MemberDefImpl::isProperty
bool isProperty() const override
Definition memberdef.cpp:5264
MemberDefImpl::visibleInIndex
bool visibleInIndex() const override
Definition memberdef.cpp:4194
MemberDefImpl::argumentList
const ArgumentList & argumentList() const override
Definition memberdef.cpp:5618
MemberDefImpl::setDocumentedEnumValues
void setDocumentedEnumValues(bool value) override
Definition memberdef.cpp:5950
MemberDefImpl::m_detailedDescriptionCachedValue
bool m_detailedDescriptionCachedValue
Definition memberdef.cpp:501
MemberDefImpl::isTypedefValCached
bool isTypedefValCached() const override
Definition memberdef.cpp:5767
MemberDefImpl::isInline
bool isInline() const override
Definition memberdef.cpp:5289
MemberDefImpl::getExamples
const ExampleList & getExamples() const override
Definition memberdef.cpp:5608
MemberDefImpl::m_defTmpArgLists
ArgumentLists m_defTmpArgLists
Definition memberdef.cpp:454
MemberDefImpl::isFriendToHide
bool isFriendToHide() const override
Definition memberdef.cpp:6406
MemberDefImpl::setFromAnonymousScope
void setFromAnonymousScope(bool b) override
Definition memberdef.cpp:6003
MemberDefImpl::fromAnonymousScope
bool fromAnonymousScope() const override
Definition memberdef.cpp:5696
MemberDefImpl::invalidateTypedefValCache
void invalidateTypedefValCache() override
Definition memberdef.cpp:6039
MemberDefImpl::accessorClass
ClassDef * accessorClass() const override
Definition memberdef.cpp:4933
MemberDefImpl::isFriendClass
bool isFriendClass() const override
Definition memberdef.cpp:6416
MemberDefImpl::setNamespace
void setNamespace(NamespaceDef *nd) override
Definition memberdef.cpp:4458
MemberDefImpl::setProtection
void setProtection(Protection p) override
Definition memberdef.cpp:5850
MemberDefImpl::getNamespaceDef
const NamespaceDef * getNamespaceDef() const override
Definition memberdef.cpp:5134
MemberDefImpl::setHidden
void setHidden(bool b) override
Definition memberdef.cpp:1905
MemberDefImpl::_writeEnumValues
void _writeEnumValues(OutputList &ol, const Definition *container, const QCString &cfname, const QCString &ciname, const QCString &cname) const
Definition memberdef.cpp:3213
MemberDefImpl::_writeTypeConstraints
void _writeTypeConstraints(OutputList &ol) const
Definition memberdef.cpp:3205
MemberDefImpl::isSliceLocal
bool isSliceLocal() const override
Definition memberdef.cpp:5578
MemberDefImpl::m_args
QCString m_args
Definition memberdef.cpp:422
MemberDefImpl::makeRelated
void makeRelated() override
Definition memberdef.cpp:5916
MemberDefImpl::getGroupStartLine
int getGroupStartLine() const override
Definition memberdef.cpp:5179
MemberDefImpl::warnIfUndocumented
void warnIfUndocumented() const override
Definition memberdef.cpp:4122
MemberDefImpl::m_hasReferencedByRelation
bool m_hasReferencedByRelation
Definition memberdef.cpp:505
MemberDefImpl::setDefinition
void setDefinition(const QCString &d) override
Definition memberdef.cpp:5832
MemberDefImpl::objCMethodName
QCString objCMethodName(bool localLink, bool showStatic) const override
Definition memberdef.cpp:5032
MemberDefImpl::setMemberType
void setMemberType(MemberType t) override
Definition memberdef.cpp:5826
MemberDefImpl::getWriteAccessor
QCString getWriteAccessor() const override
Definition memberdef.cpp:5149
MemberDefImpl::typeConstraints
const ArgumentList & typeConstraints() const override
Definition memberdef.cpp:6401
MemberDefImpl::definitionType
DefType definitionType() const override
Definition memberdef.cpp:64
MemberDefImpl::setEnumBaseType
void setEnumBaseType(const QCString &type) override
Definition memberdef.cpp:6074
MemberDefImpl::isDestructor
bool isDestructor() const override
Definition memberdef.cpp:4771
MemberDefImpl::getQualifiers
StringVector getQualifiers() const override
Definition memberdef.cpp:5871
MemberDefImpl::qualifiedName
QCString qualifiedName() const override
Definition memberdef.cpp:4997
MemberDefImpl::m_virt
Specifier m_virt
Definition memberdef.cpp:425
MemberDefImpl::setRedefineCount
void setRedefineCount(int) override
Definition memberdef.cpp:6474
MemberDefImpl::setAnonymousEnumType
void setAnonymousEnumType(const MemberDef *md) override
Definition memberdef.cpp:5955
MemberDefImpl::isOptional
bool isOptional() const override
Definition memberdef.cpp:5394
MemberDefImpl::_writeExamples
void _writeExamples(OutputList &ol) const
Definition memberdef.cpp:3192
MemberDefImpl::moveTo
void moveTo(Definition *) override
Definition memberdef.cpp:1563
MemberDefImpl::isCallable
bool isCallable() const override
Definition memberdef.cpp:5537
MemberDefImpl::getCachedResolvedTypedef
QCString getCachedResolvedTypedef() const override
Definition memberdef.cpp:5782
MemberDefImpl::anchor
QCString anchor() const override
Definition memberdef.cpp:1780
MemberDefImpl::m_docTransferDone
bool m_docTransferDone
Definition memberdef.cpp:438
MemberDefImpl::isBriefSectionVisible
bool isBriefSectionVisible() const override
Definition memberdef.cpp:2050
MemberDefImpl::m_anc
QCString m_anc
Definition memberdef.cpp:424
MemberDefImpl::m_categoryRelation
const MemberDef * m_categoryRelation
Definition memberdef.cpp:516
MemberDefImpl::init
void init(Definition *def, const QCString &t, const QCString &a, const QCString &e, Protection p, Specifier v, bool s, Relationship r, MemberType mt, const ArgumentList &tal, const ArgumentList &al, const QCString &meta)
Definition memberdef.cpp:1340
MemberDefImpl::addExample
bool addExample(const QCString &anchor, const QCString &name, const QCString &file) override
Definition memberdef.cpp:1642
MemberDefImpl::setCategoryRelation
void setCategoryRelation(const MemberDef *) override
Definition memberdef.cpp:6069
MemberDefImpl::isReference
bool isReference() const override
Definition memberdef.cpp:6439
MemberDefImpl::extraTypeChars
QCString extraTypeChars() const override
Definition memberdef.cpp:5059
MemberDefImpl::m_prot
Protection m_prot
Definition memberdef.cpp:426
MemberDefImpl::getDeclType
QCString getDeclType() const override
Definition memberdef.cpp:2143
MemberDefImpl::warnIfUndocumentedParams
void warnIfUndocumentedParams() const override
Definition memberdef.cpp:4284
MemberDefImpl::getVhdlSpecifiers
VhdlSpecifier getVhdlSpecifiers() const override
Definition memberdef.cpp:5104
MemberDefImpl::_hasVisibleCallGraph
bool _hasVisibleCallGraph() const
Definition memberdef.cpp:5706
MemberDefImpl::setFormalTemplateArguments
void setFormalTemplateArguments(const ArgumentList &al) override
Definition memberdef.cpp:6024
MemberDefImpl::m_category
ClassDef * m_category
Definition memberdef.cpp:515
MemberDefImpl::isDefine
bool isDefine() const override
Definition memberdef.cpp:5249
MemberDefImpl::findSectionsInDocumentation
void findSectionsInDocumentation() override
Definition memberdef.cpp:4938
MemberDefImpl::getClassDefOfAnonymousType
ClassDef * getClassDefOfAnonymousType() const override
Definition memberdef.cpp:1998
MemberDefImpl::briefDescription
QCString briefDescription(bool abbr=FALSE) const override
Definition memberdef.cpp:6365
MemberDefImpl::setFileDef
void setFileDef(FileDef *fd) override
Definition memberdef.cpp:5837
MemberDefImpl::resolveAlias
const MemberDef * resolveAlias() const override
Definition memberdef.cpp:66
MemberDefImpl::m_declArgList
ArgumentList m_declArgList
Definition memberdef.cpp:448
MemberDefImpl::deepCopy
std::unique_ptr< MemberDef > deepCopy() const override
Definition memberdef.cpp:1463
MemberDefImpl::makeForeign
void makeForeign() override
Definition memberdef.cpp:5922
MemberDefImpl::m_memDec
MemberDef * m_memDec
Definition memberdef.cpp:414
MemberDefImpl::m_isConstructorCached
uint8_t m_isConstructorCached
Definition memberdef.cpp:397
MemberDefImpl::hasMultiLineInitializer
bool hasMultiLineInitializer() const override
Definition memberdef.cpp:4518
MemberDefImpl::hasCallGraph
bool hasCallGraph() const override
Definition memberdef.cpp:5701
MemberDefImpl::memberTypeName
QCString memberTypeName() const override
Definition memberdef.cpp:4109
MemberDefImpl::_writeReimplementedBy
void _writeReimplementedBy(OutputList &ol) const
Definition memberdef.cpp:3080
MemberDefImpl::isNew
bool isNew() const override
Definition memberdef.cpp:5369
MemberDefImpl::setMaxInitLines
void setMaxInitLines(int lines) override
Definition memberdef.cpp:5893
MemberDefImpl::writeDeclaration
void writeDeclaration(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool inGroup, int indentLevel, const ClassDef *inheritFrom=nullptr, const QCString &inheritId=QCString()) const override
Definition memberdef.cpp:2238
MemberDefImpl::isDocsForDefinition
bool isDocsForDefinition() const override
Definition memberdef.cpp:5563
MemberDefImpl::initializer
const QCString & initializer() const override
Definition memberdef.cpp:5084
MemberDefImpl::setEnumClassScope
void setEnumClassScope(ClassDef *cd) override
Definition memberdef.cpp:5943
MemberDefImpl::isUnretained
bool isUnretained() const override
Definition memberdef.cpp:5446
MemberDefImpl::m_annMemb
MemberDef * m_annMemb
Definition memberdef.cpp:445
MemberDefImpl::isGettable
bool isGettable() const override
Definition memberdef.cpp:5309
MemberDefImpl::getMemberGroup
MemberGroup * getMemberGroup() const override
Definition memberdef.cpp:5691
MemberDefImpl::hasUserDocumentation
bool hasUserDocumentation() const override
Definition memberdef.cpp:6389
MemberDefImpl::formalTemplateArguments
std::optional< ArgumentList > formalTemplateArguments() const override
Definition memberdef.cpp:5762
MemberDefImpl::m_sectionMap
std::map< const Definition *, const MemberList * > m_sectionMap
Definition memberdef.cpp:463
MemberDefImpl::isEnumValue
bool isEnumValue() const override
Definition memberdef.cpp:5219
MemberDefImpl::isObjCMethod
bool isObjCMethod() const override
Definition memberdef.cpp:4979
MemberDefImpl::memberDefinition
MemberDef * memberDefinition() const override
Definition memberdef.cpp:5788
MemberDefImpl::m_isTypedefValCached
bool m_isTypedefValCached
Definition memberdef.cpp:474
MemberDefImpl::m_hasDocumentedReturnType
bool m_hasDocumentedReturnType
Definition memberdef.cpp:492
MemberDefImpl::setFromAnonymousMember
void setFromAnonymousMember(MemberDef *m) override
Definition memberdef.cpp:6008
MemberDefImpl::m_extraTypeChars
QCString m_extraTypeChars
Definition memberdef.cpp:434
MemberDefImpl::m_qualifiers
StringVector m_qualifiers
Definition memberdef.cpp:486
MemberDefImpl::overrideCallGraph
void overrideCallGraph(bool e) override
Definition memberdef.cpp:4945
MemberDefImpl::setInheritsDocsFrom
void setInheritsDocsFrom(const MemberDef *md) override
Definition memberdef.cpp:5928
MemberDefImpl::setAccessorType
void setAccessorType(ClassDef *cd, const QCString &t) override
Definition memberdef.cpp:4927
MemberDefImpl::setType
void setType(const QCString &t) override
Definition memberdef.cpp:4922
MemberDefImpl::virtualness
Specifier virtualness(int count=0) const override
Definition memberdef.cpp:4607
MemberDefImpl::getClassDefMutable
ClassDefMutable * getClassDefMutable() override
Definition memberdef.cpp:5119
MemberDefImpl::m_type
QCString m_type
Definition memberdef.cpp:419
MemberDefImpl::hasDetailedDescription
bool hasDetailedDescription() const override
Definition memberdef.cpp:2674
MemberDefImpl::setMemberGroupId
void setMemberGroupId(int id) override
Definition memberdef.cpp:5993
MemberDefImpl::bitfieldString
QCString bitfieldString() const override
Definition memberdef.cpp:5079
MemberDefImpl::isCSharpProperty
bool isCSharpProperty() const override
Definition memberdef.cpp:4991
MemberDefImpl::setSectionList
void setSectionList(const Definition *container, const MemberList *sl) override
Definition memberdef.cpp:4601
MemberDefImpl::definition
QCString definition() const override
Definition memberdef.cpp:5054
MemberDefImpl::isRaisable
bool isRaisable() const override
Definition memberdef.cpp:5349
MemberDefImpl::setTemplateMaster
void setTemplateMaster(const MemberDef *mt) override
Definition memberdef.cpp:6018
MemberDefImpl::setDocumentation
void setDocumentation(const QCString &d, const QCString &docFile, int docLine, bool stripWhiteSpace=TRUE) override
Definition memberdef.cpp:1882
MemberDefImpl::createTemplateInstanceMember
std::unique_ptr< MemberDef > createTemplateInstanceMember(const ArgumentList &formalArgs, const std::unique_ptr< ArgumentList > &actualArgs) const override
Definition memberdef.cpp:4464
MemberDefImpl::getGroupDef
const GroupDef * getGroupDef() const override
Definition memberdef.cpp:5154
MemberDefImpl::isRelatedOrFriend
bool isRelatedOrFriend() const override
Definition memberdef.cpp:6434
MemberDefImpl::insertEnumField
void insertEnumField(MemberDef *md) override
Definition memberdef.cpp:1637
MemberDefImpl::isMutable
bool isMutable() const override
Definition memberdef.cpp:5299
MemberDefImpl::isPublished
bool isPublished() const override
Definition memberdef.cpp:5516
MemberDefImpl::isLinkableInProject
bool isLinkableInProject() const override
Definition memberdef.cpp:1911
MemberDefImpl::isProtectedSettable
bool isProtectedSettable() const override
Definition memberdef.cpp:5334
MemberDefImpl::getDeclFileName
QCString getDeclFileName() const override
Definition memberdef.cpp:5808
MemberDefImpl::setMemberGroup
void setMemberGroup(MemberGroup *grp) override
Definition memberdef.cpp:4365
MemberDefImpl::setMemberDeclaration
void setMemberDeclaration(MemberDef *md) override
Definition memberdef.cpp:6049
MemberDefImpl::enumBaseType
QCString enumBaseType() const override
Definition memberdef.cpp:6079
MemberDefImpl::isUNOProperty
bool isUNOProperty() const override
Definition memberdef.cpp:5476
MemberDefImpl::m_hasDocumentedParams
bool m_hasDocumentedParams
Definition memberdef.cpp:491
MemberDefImpl::m_moduleDef
ModuleDef * m_moduleDef
Definition memberdef.cpp:403
MemberDefImpl::m_hasReferencesRelation
bool m_hasReferencesRelation
Definition memberdef.cpp:506
MemberDefImpl::_computeIsConstructor
void _computeIsConstructor()
Definition memberdef.cpp:4692
MemberDefImpl::displayName
QCString displayName(bool=TRUE) const override
Definition memberdef.cpp:6171
MemberDefImpl::_countReimplementedBy
size_t _countReimplementedBy() const
Definition memberdef.cpp:3063
MemberDefImpl::isRequired
bool isRequired() const override
Definition memberdef.cpp:5399
MemberDefImpl::reimplementedBy
const MemberVector & reimplementedBy() const override
Definition memberdef.cpp:1613
MemberDefImpl::isStrong
bool isStrong() const override
Definition memberdef.cpp:5429
MemberDefImpl::m_hasInlineSource
bool m_hasInlineSource
Definition memberdef.cpp:507
MemberDefImpl::fromAnonymousMember
MemberDef * fromAnonymousMember() const override
Definition memberdef.cpp:6013
MemberDefImpl::moveDeclArgumentList
void moveDeclArgumentList(std::unique_ptr< ArgumentList > al) override
Definition memberdef.cpp:4912
MemberDefImpl::isTypeAlias
bool isTypeAlias() const override
Definition memberdef.cpp:5451
MemberDefImpl::setMemberClass
void setMemberClass(ClassDef *cd) override
Definition memberdef.cpp:4450
MemberDefImpl::m_initializer
QCString m_initializer
Definition memberdef.cpp:433
MemberDefImpl::excpString
QCString excpString() const override
Definition memberdef.cpp:5074
MemberDefImpl::templateMaster
const MemberDef * templateMaster() const override
Definition memberdef.cpp:5757
MemberDefImpl::setDocsForDefinition
void setDocsForDefinition(bool b) override
Definition memberdef.cpp:6029
MemberDefImpl::getCachedTypedefVal
const ClassDef * getCachedTypedefVal() const override
Definition memberdef.cpp:5772
MemberDefImpl::initializerLines
int initializerLines() const override
Definition memberdef.cpp:5089
MemberDefImpl::setBitfields
void setBitfields(const QCString &s) override
Definition memberdef.cpp:5888
MemberDefImpl::getGroupHasDocs
bool getGroupHasDocs() const override
Definition memberdef.cpp:5184
MemberDefImpl::getEnumScope
const MemberDef * getEnumScope() const override
Definition memberdef.cpp:5568
MemberDefImpl::m_hasCallerGraph
bool m_hasCallerGraph
Definition memberdef.cpp:504
MemberDefImpl::argsString
QCString argsString() const override
Definition memberdef.cpp:5069
MemberDefImpl::isMaybeDefault
bool isMaybeDefault() const override
Definition memberdef.cpp:5506
MemberDefImpl::m_groupFileName
QCString m_groupFileName
Definition memberdef.cpp:470
MemberDefImpl::m_nspace
NamespaceDef * m_nspace
Definition memberdef.cpp:402
MemberDefImpl::isReimplementedBy
bool isReimplementedBy(const ClassDef *cd) const override
Definition memberdef.cpp:1618
MemberDefImpl::getLabels
StringVector getLabels(const Definition *container) const override
Definition memberdef.cpp:2808
MemberDefImpl::isTransient
bool isTransient() const override
Definition memberdef.cpp:5496
MemberDefImpl::m_defArgList
ArgumentList m_defArgList
Definition memberdef.cpp:447
MemberDefImpl::m_docsForDefinition
bool m_docsForDefinition
Definition memberdef.cpp:512
MemberDefImpl::memberDeclaration
MemberDef * memberDeclaration() const override
Definition memberdef.cpp:5793
MemberDefImpl::m_formalTemplateArguments
std::optional< ArgumentList > m_formalTemplateArguments
Definition memberdef.cpp:453
MemberDefImpl::isInitonly
bool isInitonly() const override
Definition memberdef.cpp:5384
MemberDefImpl::isAddable
bool isAddable() const override
Definition memberdef.cpp:5339
MemberDefImpl::m_read
QCString m_read
Definition memberdef.cpp:430
MemberDefImpl::isRelated
bool isRelated() const override
Definition memberdef.cpp:5274
MemberDefImpl::moveArgumentList
void moveArgumentList(std::unique_ptr< ArgumentList > al) override
Definition memberdef.cpp:4907
MemberDefImpl::m_decl
QCString m_decl
Definition memberdef.cpp:427
MemberDefImpl::m_cachedTypedefValue
const ClassDef * m_cachedTypedefValue
Definition memberdef.cpp:475
MemberDefImpl::m_redefines
MemberDef * m_redefines
Definition memberdef.cpp:410
MemberDefImpl::m_accessorType
QCString m_accessorType
Definition memberdef.cpp:420
MemberDefImpl::setCategory
void setCategory(ClassDef *) override
Definition memberdef.cpp:6059
MemberDefImpl::m_isDestructorCached
uint8_t m_isDestructorCached
Definition memberdef.cpp:398
MemberDefImpl::memberType
MemberType memberType() const override
Definition memberdef.cpp:5194
MemberDefImpl::getScopeString
QCString getScopeString() const override
Definition memberdef.cpp:4370
MemberDefImpl::protection
Protection protection() const override
Definition memberdef.cpp:5189
MemberDefImpl::isConstructor
bool isConstructor() const override
Definition memberdef.cpp:4730
MemberDefImpl::setGroupAlias
void setGroupAlias(const MemberDef *md) override
Definition memberdef.cpp:6034
MemberDefImpl::isEnumerate
bool isEnumerate() const override
Definition memberdef.cpp:5214
MemberDefImpl::templateArguments
const ArgumentList & templateArguments() const override
Definition memberdef.cpp:5676
MemberDefImpl::isCopy
bool isCopy() const override
Definition memberdef.cpp:5409
MemberDefImpl::isReadonly
bool isReadonly() const override
Definition memberdef.cpp:5481
MemberDefImpl::declaration
QCString declaration() const override
Definition memberdef.cpp:5049
MemberDefImpl::m_accessorClass
ClassDef * m_accessorClass
Definition memberdef.cpp:421
MemberDefImpl::setTagInfo
void setTagInfo(const TagInfo *i) override
Definition memberdef.cpp:5021
MemberDefImpl::definitionTemplateParameterLists
const ArgumentLists & definitionTemplateParameterLists() const override
Definition memberdef.cpp:5681
MemberDefImpl::_writeTemplatePrefix
void _writeTemplatePrefix(OutputList &ol, const Definition *def, const ArgumentList &al, bool writeReqClause=true) const
Definition memberdef.cpp:2190
MemberDefImpl::isStatic
bool isStatic() const override
Definition memberdef.cpp:5284
MemberDefImpl::writeTagFile
void writeTagFile(TextStream &, bool useQualifiedName, bool showNamespaceMembers) const override
Definition memberdef.cpp:4625
MemberDefImpl::m_classDef
ClassDef * m_classDef
Definition memberdef.cpp:400
MemberDefImpl::resolveAlias
MemberDef * resolveAlias() override
Definition memberdef.cpp:65
MemberDefImpl::isFinal
bool isFinal() const override
Definition memberdef.cpp:5364
MemberDefImpl::m_requiresClause
QCString m_requiresClause
Definition memberdef.cpp:436
MemberDefImpl::isAttribute
bool isAttribute() const override
Definition memberdef.cpp:5471
MemberDefImpl::m_enumScope
const MemberDef * m_enumScope
Definition memberdef.cpp:405
MemberDefImpl::redefineCount
int redefineCount() const override
Definition memberdef.cpp:6469
MemberDefImpl::isDictionary
bool isDictionary() const override
Definition memberdef.cpp:5234
MemberDefImpl::isSlot
bool isSlot() const override
Definition memberdef.cpp:5204
MemberDefImpl::hasInlineSource
bool hasInlineSource() const override
Definition memberdef.cpp:5747
MemberDefImpl::setAnchor
void setAnchor() override
Definition memberdef.cpp:4379
MemberDefImpl::m_related
Relationship m_related
Definition memberdef.cpp:494
MemberDefImpl::m_bitfields
QCString m_bitfields
Definition memberdef.cpp:429
MemberDefImpl::m_memberGroup
MemberGroup * m_memberGroup
Definition memberdef.cpp:467
MemberDefImpl::m_groupAlias
const MemberDef * m_groupAlias
Definition memberdef.cpp:465
MemberDefImpl::isRetain
bool isRetain() const override
Definition memberdef.cpp:5419
MemberDefImpl::m_redefinedBy
MemberVector m_redefinedBy
Definition memberdef.cpp:411
MemberDefImpl::category
ClassDef * category() const override
Definition memberdef.cpp:6054
MemberDefImpl::overrideEnumValues
void overrideEnumValues(bool e) override
Definition memberdef.cpp:4969
MemberDefImpl::isDocTransferDone
bool isDocTransferDone() const override
Definition memberdef.cpp:5094
MemberDefImpl::isDocumentedFriendClass
bool isDocumentedFriendClass() const override
Definition memberdef.cpp:4342
MemberDefImpl::isConstEval
bool isConstEval() const override
Definition memberdef.cpp:5593
MemberDefImpl::hasReferencesRelation
bool hasReferencesRelation() const override
Definition memberdef.cpp:5742
MemberDefImpl::_writeTagData
void _writeTagData(const DefType) const
MemberDefImpl::overrideReferencedByRelation
void overrideReferencedByRelation(bool e) override
Definition memberdef.cpp:4957
MemberDefImpl::isEnumStruct
bool isEnumStruct() const override
Definition memberdef.cpp:5434
MemberDefImpl::hasEnumValues
bool hasEnumValues() const override
Definition memberdef.cpp:5752
MemberDefImpl::setInbodyDocumentation
void setInbodyDocumentation(const QCString &d, const QCString &inbodyFile, int inbodyLine) override
Definition memberdef.cpp:1899
MemberDefImpl::isExplicit
bool isExplicit() const override
Definition memberdef.cpp:5294
MemberDefImpl::_writeCategoryRelation
void _writeCategoryRelation(OutputList &ol) const
Definition memberdef.cpp:3139
MemberDefImpl::setTemplateSpecialization
void setTemplateSpecialization(bool b) override
Definition memberdef.cpp:5911
MemberDefImpl::isTemplateSpecialization
bool isTemplateSpecialization() const override
Definition memberdef.cpp:5532
MemberDefImpl::setInitializer
void setInitializer(const QCString &i) override
Definition memberdef.cpp:4529
MemberDefImpl::fieldType
QCString fieldType() const override
Definition memberdef.cpp:3985
MemberDefImpl::inheritsDocsFrom
const MemberDef * inheritsDocsFrom() const override
Definition memberdef.cpp:5798
MemberDefImpl::getDeclLine
int getDeclLine() const override
Definition memberdef.cpp:5813
MemberDefImpl::setTypeConstraints
void setTypeConstraints(const ArgumentList &al) override
Definition memberdef.cpp:4917
MemberDefImpl::setVhdlSpecifiers
void setVhdlSpecifiers(VhdlSpecifier s) override
Definition memberdef.cpp:5861
MemberDefImpl::isImplementation
bool isImplementation() const override
Definition memberdef.cpp:5522
MemberDefImpl::_writeMultiLineInitializer
void _writeMultiLineInitializer(OutputList &ol, const QCString &scopeName) const
Definition memberdef.cpp:3444
MemberDefImpl::livesInsideEnum
bool livesInsideEnum() const override
Definition memberdef.cpp:5573
MemberDefImpl::isDelete
bool isDelete() const override
Definition memberdef.cpp:5461
MemberDefImpl::setEnumScope
void setEnumScope(MemberDef *md, bool livesInsideEnum=FALSE) override
Definition memberdef.cpp:4435
MemberDefImpl::getCachedTypedefTemplSpec
QCString getCachedTypedefTemplSpec() const override
Definition memberdef.cpp:5777
MemberDefImpl::setGroupDef
void setGroupDef(GroupDef *gd, Grouping::GroupPri_t pri, const QCString &fileName, int startLine, bool hasDocs, MemberDef *member=nullptr) override
Definition memberdef.cpp:4421
MemberDefImpl::isNoExcept
bool isNoExcept() const override
Definition memberdef.cpp:5466
MemberDefImpl::getOutputFileBase
QCString getOutputFileBase() const override
Definition memberdef.cpp:1673
MemberDefImpl::isWeak
bool isWeak() const override
Definition memberdef.cpp:5424
MemberDefImpl::getAnonymousEnumType
const MemberDef * getAnonymousEnumType() const override
Definition memberdef.cpp:5558
MemberDefImpl::getModuleDef
const ModuleDef * getModuleDef() const override
Definition memberdef.cpp:5164
MemberDefImpl::setDocTransferDone
void setDocTransferDone() override
Definition memberdef.cpp:1894
MemberDefImpl::setRequiresClause
void setRequiresClause(const QCString &req) override
Definition memberdef.cpp:6084
MemberDefImpl::isNoDiscard
bool isNoDiscard() const override
Definition memberdef.cpp:5583
MemberDefImpl::setPrototype
void setPrototype(bool p, const QCString &df, int line, int column) override
Definition memberdef.cpp:5960
MemberDefImpl::m_group
GroupDef * m_group
Definition memberdef.cpp:468
MemberDefImpl::incrementFlowKeyWordCount
void incrementFlowKeyWordCount() override
Definition memberdef.cpp:6159
MemberDefImpl::getGroupAlias
const MemberDef * getGroupAlias() const override
Definition memberdef.cpp:5803
MemberDefImpl::isConstInit
bool isConstInit() const override
Definition memberdef.cpp:5598
MemberDefImpl::setModuleDef
void setModuleDef(ModuleDef *mod) override
Definition memberdef.cpp:5845
MemberDefImpl::m_metaData
QCString m_metaData
Definition memberdef.cpp:457
MemberDefImpl::m_memSpec
TypeSpecifier m_memSpec
Definition memberdef.cpp:440
MemberDefImpl::getMemberSpecifiers
TypeSpecifier getMemberSpecifiers() const override
Definition memberdef.cpp:5099
MemberDefImpl::hasReferencedByRelation
bool hasReferencedByRelation() const override
Definition memberdef.cpp:5737
MemberDefImpl::setDeclFile
void setDeclFile(const QCString &df, int line, int column) override
Definition memberdef.cpp:5986
MemberDefImpl::makeImplementationDetail
void makeImplementationDetail() override
Definition memberdef.cpp:5998
MemberDefImpl::getGroupPri
Grouping::GroupPri_t getGroupPri() const override
Definition memberdef.cpp:5169
MemberDefImpl::isLinkable
bool isLinkable() const override
Definition memberdef.cpp:1922
MemberDefImpl::hasDocumentation
bool hasDocumentation() const override
Definition memberdef.cpp:4357
MemberDefImpl::numberOfFlowKeyWords
int numberOfFlowKeyWords() const override
Definition memberdef.cpp:6164
MemberDefImpl::isProtectedGettable
bool isProtectedGettable() const override
Definition memberdef.cpp:5319
MemberDefImpl::m_hasDetailedDescriptionCached
bool m_hasDetailedDescriptionCached
Definition memberdef.cpp:500
MemberDefImpl::setDefinitionTemplateParameterLists
void setDefinitionTemplateParameterLists(const ArgumentLists &lists) override
Definition memberdef.cpp:1935
MemberDefImpl::m_examples
ExampleList m_examples
Definition memberdef.cpp:417
MemberDefImpl::declArgumentList
const ArgumentList & declArgumentList() const override
Definition memberdef.cpp:5623
MemberDefImpl::invalidateCachedArgumentTypes
void invalidateCachedArgumentTypes() override
Definition memberdef.cpp:6153
MemberDefImpl::_isAnonymousBitField
bool _isAnonymousBitField() const
Definition memberdef.cpp:2233
MemberDefImpl::m_cachedTypedefTemplSpec
QCString m_cachedTypedefTemplSpec
Definition memberdef.cpp:476
MemberDefImpl::detectUndocumentedParams
void detectUndocumentedParams(bool hasParamCommand, bool hasReturnCommand) const override
Definition memberdef.cpp:4220
MemberDefImpl::m_relatedAlso
ClassDef * m_relatedAlso
Definition memberdef.cpp:415
MemberDefImpl::m_annEnumType
const MemberDef * m_annEnumType
Definition memberdef.cpp:407
MemberDefImpl::isWritable
bool isWritable() const override
Definition memberdef.cpp:5359
MemberDefImpl::m_templateMaster
const MemberDef * m_templateMaster
Definition memberdef.cpp:452
MemberDefImpl::isSealed
bool isSealed() const override
Definition memberdef.cpp:5374
MemberDefImpl::setWriteAccessor
void setWriteAccessor(const QCString &w) override
Definition memberdef.cpp:5906
MemberDefImpl::isAbstract
bool isAbstract() const override
Definition memberdef.cpp:5389
MemberDefImpl::isPrivateSettable
bool isPrivateSettable() const override
Definition memberdef.cpp:5329
MemberDefImpl::setArgsString
void setArgsString(const QCString &as) override
Definition memberdef.cpp:5933
MemberDefImpl::getReference
QCString getReference() const override
Definition memberdef.cpp:1741
MemberDefImpl::isSequence
bool isSequence() const override
Definition memberdef.cpp:5229
MemberDefImpl::_computeLinkableInProject
void _computeLinkableInProject()
Definition memberdef.cpp:1803
MemberDefImpl::MemberDefImpl
MemberDefImpl(const QCString &defFileName, int defLine, int defColumn, const QCString &type, const QCString &name, const QCString &args, const QCString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const QCString &metaData)
Definition memberdef.cpp:1450
MemberDefImpl::m_enumBaseType
QCString m_enumBaseType
Definition memberdef.cpp:435
MemberDefImpl::m_grouppri
Grouping::GroupPri_t m_grouppri
Definition memberdef.cpp:469
MemberDefImpl::setRelatedAlso
void setRelatedAlso(ClassDef *cd) override
Definition memberdef.cpp:5938
MemberDefImpl::addRequirementReferences
void addRequirementReferences(const Definition *) override
Definition memberdef.cpp:4590
MemberDefImpl::hasExamples
bool hasExamples() const override
Definition memberdef.cpp:1648
MemberDefImpl::resolveUnnamedParameters
void resolveUnnamedParameters(const MemberDef *md) override
Definition memberdef.cpp:5628
MemberDefImpl::setMemberDefinition
void setMemberDefinition(MemberDef *md) override
Definition memberdef.cpp:6044
MemberDefImpl::isThreadLocal
bool isThreadLocal() const override
Definition memberdef.cpp:5304
MemberDefImpl::writeMemberDocSimple
void writeMemberDocSimple(OutputList &ol, const Definition *container) const override
Definition memberdef.cpp:3997
MemberDefImpl::cacheTypedefVal
void cacheTypedefVal(const ClassDef *val, const QCString &templSpec, const QCString &resolvedType) override
Definition memberdef.cpp:6094
MemberDefImpl::documentation
QCString documentation() const override
Definition memberdef.cpp:6377
MemberDefImpl::isSignal
bool isSignal() const override
Definition memberdef.cpp:5199
MemberDefImpl::isMaybeVoid
bool isMaybeVoid() const override
Definition memberdef.cpp:5501
MemberDefImpl::_writeReimplements
void _writeReimplements(OutputList &ol) const
Definition memberdef.cpp:3004
MemberDefImpl::isMaybeAmbiguous
bool isMaybeAmbiguous() const override
Definition memberdef.cpp:5511
MemberDefImpl::hasOneLineInitializer
bool hasOneLineInitializer() const override
Definition memberdef.cpp:4507
MemberDefImpl::getSectionList
const MemberList * getSectionList(const Definition *) const override
Definition memberdef.cpp:4595
MemberDefImpl::setReadAccessor
void setReadAccessor(const QCString &r) override
Definition memberdef.cpp:5901
MemberDefImpl::isForeign
bool isForeign() const override
Definition memberdef.cpp:5279
MemberDefImpl::addQualifiers
void addQualifiers(const StringVector &qualifiers) override
Definition memberdef.cpp:5876
MemberDefImpl::typeString
QCString typeString() const override
Definition memberdef.cpp:5064
MemberDefImpl::isAssign
bool isAssign() const override
Definition memberdef.cpp:5414
MemberDefImpl::isStrongEnumValue
bool isStrongEnumValue() const override
Definition memberdef.cpp:5439
MemberDefImpl::_computeIsDestructor
void _computeIsDestructor()
Definition memberdef.cpp:4742
MemberDefImpl::isNotFriend
bool isNotFriend() const override
Definition memberdef.cpp:6424
MemberDefImpl::copyArgumentNames
void copyArgumentNames(const MemberDef *bmd) override
Definition memberdef.cpp:6103
MemberDefImpl::isRemovable
bool isRemovable() const override
Definition memberdef.cpp:5344
MemberDefImpl::isDeleted
bool isDeleted() const override
Definition memberdef.cpp:4352
MemberDefImpl::m_memDef
MemberDef * m_memDef
Definition memberdef.cpp:413
MemberDefImpl::m_groupMember
MemberDef * m_groupMember
Definition memberdef.cpp:472
MemberDefImpl::isFriend
bool isFriend() const override
Definition memberdef.cpp:5254
MemberDefImpl::m_livesInsideEnum
bool m_livesInsideEnum
Definition memberdef.cpp:406
MemberDefImpl::m_typeConstraints
ArgumentList m_typeConstraints
Definition memberdef.cpp:451
MemberDefImpl::relatedAlso
ClassDef * relatedAlso() const override
Definition memberdef.cpp:5548
MemberDefImpl::setReimplements
void setReimplements(MemberDef *md) override
Definition memberdef.cpp:1587
MemberDefImpl::m_enumFields
MemberVector m_enumFields
Definition memberdef.cpp:408
MemberDefImpl::writeEnumDeclaration
void writeEnumDeclaration(OutputList &typeDecl, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod) const override
Definition memberdef.cpp:4782
MemberDefImpl::isConstExpr
bool isConstExpr() const override
Definition memberdef.cpp:5588
MemberDefImpl::getGroupFileName
QCString getGroupFileName() const override
Definition memberdef.cpp:5174
MemberDefImpl::isExternal
bool isExternal() const override
Definition memberdef.cpp:5527
MemberDefImpl::getFileDef
const FileDef * getFileDef() const override
Definition memberdef.cpp:5124
MemberDefImpl::isNonAtomic
bool isNonAtomic() const override
Definition memberdef.cpp:5404
MemberDefImpl::categoryRelation
const MemberDef * categoryRelation() const override
Definition memberdef.cpp:6064
MemberDefImpl::enumFieldList
const MemberVector & enumFieldList() const override
Definition memberdef.cpp:5603
MemberDefImpl::getClassDef
const ClassDef * getClassDef() const override
Definition memberdef.cpp:5109
MemberDefImpl::m_def
QCString m_def
Definition memberdef.cpp:423
MemberDefImpl::isFunctionOrSignalSlot
bool isFunctionOrSignalSlot() const override
Definition memberdef.cpp:6429
MemberDefImpl::overrideInlineSource
void overrideInlineSource(bool e) override
Definition memberdef.cpp:4974
MemberDefImpl::overrideCallerGraph
void overrideCallerGraph(bool e) override
Definition memberdef.cpp:4951
MemberDefImpl::isPrivateGettable
bool isPrivateGettable() const override
Definition memberdef.cpp:5314
MemberDefImpl::setExplicitExternal
void setExplicitExternal(bool b, const QCString &df, int line, int column) override
Definition memberdef.cpp:5973
MemberDefImpl::isEvent
bool isEvent() const override
Definition memberdef.cpp:5269
MemberDefImpl::m_cachedAnonymousType
ClassDef * m_cachedAnonymousType
Definition memberdef.cpp:459
MemberDefImpl::setMemberSpecifiers
void setMemberSpecifiers(TypeSpecifier s) override
Definition memberdef.cpp:5856
MemberDefImpl::isFunctionPtr
bool isFunctionPtr() const override
Definition memberdef.cpp:5244
MemberDefImpl::m_cachedResolvedType
QCString m_cachedResolvedType
Definition memberdef.cpp:477
MemberDefImpl::hasCallerGraph
bool hasCallerGraph() const override
Definition memberdef.cpp:5719
MemberDefImpl::isObjCProperty
bool isObjCProperty() const override
Definition memberdef.cpp:4985
MemberDefImpl::isPrototype
bool isPrototype() const override
Definition memberdef.cpp:5613
MemberDefImpl::isTypedef
bool isTypedef() const override
Definition memberdef.cpp:5224
MemberDefImpl::m_write
QCString m_write
Definition memberdef.cpp:431
MemberDefImpl::_writeGroupInclude
void _writeGroupInclude(OutputList &ol, bool inGroup) const
Definition memberdef.cpp:3392
MemberDefImpl::m_fileDef
FileDef * m_fileDef
Definition memberdef.cpp:401
MemberDefImpl::hasDocumentedEnumValues
bool hasDocumentedEnumValues() const override
Definition memberdef.cpp:5553
MemberDefImpl::~MemberDefImpl
~MemberDefImpl() override=default
MemberDefImpl::m_isLinkableCached
uint8_t m_isLinkableCached
Definition memberdef.cpp:396
MemberDefImpl::m_declFileName
QCString m_declFileName
Definition memberdef.cpp:517
MemberDefImpl::m_exception
QCString m_exception
Definition memberdef.cpp:432
MemberDefImpl::isVariable
bool isVariable() const override
Definition memberdef.cpp:5209
MemberDefImpl::mergeMemberSpecifiers
void mergeMemberSpecifiers(TypeSpecifier s) override
Definition memberdef.cpp:5866
MemberDefImpl::m_tArgList
ArgumentList m_tArgList
Definition memberdef.cpp:450
MemberDefImpl::requiresClause
QCString requiresClause() const override
Definition memberdef.cpp:6089
MemberDefImpl::isConstrained
bool isConstrained() const override
Definition memberdef.cpp:5491
MemberDefImpl::isReadable
bool isReadable() const override
Definition memberdef.cpp:5354
MemberDefImpl::getReadAccessor
QCString getReadAccessor() const override
Definition memberdef.cpp:5144
MemberDefImpl::writeLink
void writeLink(OutputList &ol, const ClassDef *cd, const NamespaceDef *nd, const FileDef *fd, const GroupDef *gd, const ModuleDef *mod, bool onlyText=FALSE) const override
Definition memberdef.cpp:1940
MemberDefImpl::m_explicitOutputFileBase
QCString m_explicitOutputFileBase
Definition memberdef.cpp:483
MemberDefImpl::addListReference
void addListReference(const Definition *) override
Definition memberdef.cpp:4543
MemberDefImpl::setBriefDescription
void setBriefDescription(const QCString &b, const QCString &briefFile, int briefLine) override
Definition memberdef.cpp:1888
MemberDefImpl::isDefault
bool isDefault() const override
Definition memberdef.cpp:5456
MemberDefImpl::_writeCallGraph
void _writeCallGraph(OutputList &ol) const
Definition memberdef.cpp:2945
MemberDefImpl::isOverride
bool isOverride() const override
Definition memberdef.cpp:5379
MemberDefImpl::m_docProvider
const MemberDef * m_docProvider
Definition memberdef.cpp:480
MemberDefImpl::isSettable
bool isSettable() const override
Definition memberdef.cpp:5324
MemberDefImpl::isBound
bool isBound() const override
Definition memberdef.cpp:5486
MemberDefImpl::codeSymbolType
CodeSymbolType codeSymbolType() const override
Definition memberdef.cpp:6445
MemberDefImpl::displayDefinition
QCString displayDefinition() const override
Definition memberdef.cpp:3317
MemberDefMutable::setMemberDeclaration
virtual void setMemberDeclaration(MemberDef *md)=0
MemberDefMutable::setDocTransferDone
virtual void setDocTransferDone()=0
MemberDefMutable::resolveUnnamedParameters
virtual void resolveUnnamedParameters(const MemberDef *md)=0
MemberDefMutable::setDocsForDefinition
virtual void setDocsForDefinition(bool b)=0
MemberDefMutable::mergeMemberSpecifiers
virtual void mergeMemberSpecifiers(TypeSpecifier s)=0
MemberDefMutable::addQualifiers
virtual void addQualifiers(const StringVector &qualifiers)=0
MemberDefMutable::moveDeclArgumentList
virtual void moveDeclArgumentList(std::unique_ptr< ArgumentList > al)=0
MemberDefMutable::setGroupDef
virtual void setGroupDef(GroupDef *gd, Grouping::GroupPri_t pri, const QCString &fileName, int startLine, bool hasDocs, MemberDef *member=nullptr)=0
MemberDefMutable::setMemberDefinition
virtual void setMemberDefinition(MemberDef *md)=0
MemberDefMutable::moveArgumentList
virtual void moveArgumentList(std::unique_ptr< ArgumentList > al)=0
MemberDefMutable::insertReimplementedBy
virtual void insertReimplementedBy(MemberDef *md)=0
MemberGroup
A class representing a group of members.
Definition membergroup.h:44
MemberList
A list of MemberDef objects as shown in documentation sections.
Definition memberlist.h:125
MemberVector
A vector of MemberDef object.
Definition memberlist.h:35
MemberVector::end
iterator end() noexcept
Definition memberlist.h:56
MemberVector::begin
iterator begin() noexcept
Definition memberlist.h:54
NamespaceDef
An abstract interface of a namespace symbol.
Definition namespacedef.h:55
NamespaceDef::compoundTypeString
virtual QCString compoundTypeString() const =0
OutputCodeList::startCodeFragment
void startCodeFragment(const QCString &style)
Definition outputlist.h:279
OutputList
Class representing a list of output generators that are written to in parallel.
Definition outputlist.h:315
OutputList::writeDoc
void writeDoc(const IDocNodeAST *ast, const Definition *ctx, const MemberDef *md, int sectionLevel=-1)
Definition outputlist.h:383
OutputList::isEnabled
bool isEnabled(OutputType o)
Definition outputlist.cpp:135
OutputList::endIndent
void endIndent()
Definition outputlist.h:584
OutputList::writeString
void writeString(const QCString &text)
Definition outputlist.h:411
OutputList::startMemberDeclaration
void startMemberDeclaration()
Definition outputlist.h:569
OutputList::startMemberDoc
void startMemberDoc(const QCString &clName, const QCString &memName, const QCString &anchor, const QCString &title, int memCount, int memTotal, bool showInline)
Definition outputlist.h:531
OutputList::endDescTableRow
void endDescTableRow()
Definition outputlist.h:634
OutputList::startMemberDocName
void startMemberDocName(bool align)
Definition outputlist.h:680
OutputList::endParameterExtra
void endParameterExtra(bool last, bool one, bool bracket)
Definition outputlist.h:694
OutputList::writeChar
void writeChar(char c)
Definition outputlist.h:529
OutputList::disable
void disable(OutputType o)
Definition outputlist.cpp:115
OutputList::endMemberTemplateParams
void endMemberTemplateParams(const QCString &anchor, const QCString &inheritId)
Definition outputlist.h:499
OutputList::endMemberDocName
void endMemberDocName()
Definition outputlist.h:682
OutputList::endMemberDoc
void endMemberDoc(bool hasArgs)
Definition outputlist.h:535
OutputList::startDescTableInit
void startDescTableInit()
Definition outputlist.h:640
OutputList::startCallGraph
void startCallGraph()
Definition outputlist.h:656
OutputList::endDescTable
void endDescTable()
Definition outputlist.h:630
OutputList::startParameterExtra
void startParameterExtra()
Definition outputlist.h:692
OutputList::codeGenerators
const OutputCodeList & codeGenerators() const
Definition outputlist.h:358
OutputList::startParameterList
void startParameterList(bool openBracket)
Definition outputlist.h:700
OutputList::writeLatexSpacing
void writeLatexSpacing()
Definition outputlist.h:545
OutputList::enable
void enable(OutputType o)
Definition outputlist.cpp:125
OutputList::endInlineMemberType
void endInlineMemberType()
Definition outputlist.h:728
OutputList::endMemberDescription
void endMemberDescription()
Definition outputlist.h:567
OutputList::writeObjectLink
void writeObjectLink(const QCString &ref, const QCString &file, const QCString &anchor, const QCString &name)
Definition outputlist.h:439
OutputList::startInlineMemberType
void startInlineMemberType()
Definition outputlist.h:726
OutputList::startInlineMemberDoc
void startInlineMemberDoc()
Definition outputlist.h:734
OutputList::startMemberDescription
void startMemberDescription(const QCString &anchor, const QCString &inheritId=QCString(), bool typ=false)
Definition outputlist.h:565
OutputList::endDescTableTitle
void endDescTableTitle()
Definition outputlist.h:638
OutputList::endDoxyAnchor
void endDoxyAnchor(const QCString &fn, const QCString &anchor)
Definition outputlist.h:541
OutputList::docify
void docify(const QCString &s)
Definition outputlist.h:437
OutputList::generateDoc
void generateDoc(const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &docStr, const DocOptions &options)
Definition outputlist.cpp:168
OutputList::startIndent
void startIndent()
Definition outputlist.h:582
OutputList::startParagraph
void startParagraph(const QCString &classDef=QCString())
Definition outputlist.h:407
OutputList::endDescForItem
void endDescForItem()
Definition outputlist.h:549
OutputList::endExamples
void endExamples()
Definition outputlist.h:580
OutputList::exceptionEntry
void exceptionEntry(const QCString &prefix, bool closeBracket)
Definition outputlist.h:704
OutputList::endParagraph
void endParagraph()
Definition outputlist.h:409
OutputList::endDescTableData
void endDescTableData()
Definition outputlist.h:646
OutputList::addIndexItem
void addIndexItem(const QCString &s1, const QCString &s2)
Definition outputlist.h:590
OutputList::disableAll
void disableAll()
Definition outputlist.cpp:105
OutputList::startDescTableTitle
void startDescTableTitle()
Definition outputlist.h:636
OutputList::startExamples
void startExamples()
Definition outputlist.h:578
OutputList::endInlineMemberDoc
void endInlineMemberDoc()
Definition outputlist.h:736
OutputList::endMemberDocPrefixItem
void endMemberDocPrefixItem()
Definition outputlist.h:678
OutputList::startParameterDefVal
void startParameterDefVal(const char *separator)
Definition outputlist.h:696
OutputList::startAnonTypeScope
void startAnonTypeScope(int i1)
Definition outputlist.h:489
OutputList::endTextLink
void endTextLink()
Definition outputlist.h:444
OutputList::startBold
void startBold()
Definition outputlist.h:561
OutputList::endMemberItem
void endMemberItem(OutputGenerator::MemberItemType type)
Definition outputlist.h:495
OutputList::startDescTable
void startDescTable(const QCString &title, const bool hasInits)
Definition outputlist.h:628
OutputList::startTypewriter
void startTypewriter()
Definition outputlist.h:449
OutputList::addLabel
void addLabel(const QCString &fName, const QCString &anchor)
Definition outputlist.h:543
OutputList::startDescTableData
void startDescTableData()
Definition outputlist.h:644
OutputList::pushGeneratorState
void pushGeneratorState()
Definition outputlist.cpp:144
OutputList::insertMemberAlign
void insertMemberAlign(bool templ=FALSE)
Definition outputlist.h:517
OutputList::startDescForItem
void startDescForItem()
Definition outputlist.h:547
OutputList::endParameterDefVal
void endParameterDefVal()
Definition outputlist.h:698
OutputList::startParameterType
void startParameterType(bool first, const QCString &key)
Definition outputlist.h:684
OutputList::disableAllBut
void disableAllBut(OutputType o)
Definition outputlist.cpp:85
OutputList::endParameterName
void endParameterName()
Definition outputlist.h:690
OutputList::popGeneratorState
void popGeneratorState()
Definition outputlist.cpp:154
OutputList::endBold
void endBold()
Definition outputlist.h:563
OutputList::startDoxyAnchor
void startDoxyAnchor(const QCString &fName, const QCString &manName, const QCString &anchor, const QCString &name, const QCString &args)
Definition outputlist.h:537
OutputList::endLabels
void endLabels()
Definition outputlist.h:742
OutputList::endParameterList
void endParameterList()
Definition outputlist.h:702
OutputList::endCallGraph
void endCallGraph(DotCallGraph &g)
Definition outputlist.h:658
OutputList::startInlineMemberName
void startInlineMemberName()
Definition outputlist.h:730
OutputList::writeLabel
void writeLabel(const QCString &l, bool isLast)
Definition outputlist.h:740
OutputList::startLabels
void startLabels()
Definition outputlist.h:738
OutputList::endParameterType
void endParameterType()
Definition outputlist.h:686
OutputList::startMemberDocPrefixItem
void startMemberDocPrefixItem()
Definition outputlist.h:676
OutputList::endAnonTypeScope
void endAnonTypeScope(int i1)
Definition outputlist.h:491
OutputList::endMemberDeclaration
void endMemberDeclaration(const QCString &anchor, const QCString &inheritId)
Definition outputlist.h:571
OutputList::startParameterName
void startParameterName(bool one)
Definition outputlist.h:688
OutputList::enableAll
void enableAll()
Definition outputlist.cpp:95
OutputList::startMemberItem
void startMemberItem(const QCString &anchor, OutputGenerator::MemberItemType type, const QCString &id=QCString())
Definition outputlist.h:493
OutputList::endTypewriter
void endTypewriter()
Definition outputlist.h:451
OutputList::endInlineMemberName
void endInlineMemberName()
Definition outputlist.h:732
OutputList::lineBreak
void lineBreak(const QCString &style=QCString())
Definition outputlist.h:559
OutputList::parseText
void parseText(const QCString &textStr)
Definition outputlist.cpp:199
OutputList::writeNonBreakableSpace
void writeNonBreakableSpace(int num)
Definition outputlist.h:626
OutputList::endDescTableInit
void endDescTableInit()
Definition outputlist.h:642
OutputList::startTextLink
void startTextLink(const QCString &file, const QCString &anchor)
Definition outputlist.h:442
OutputList::startDescTableRow
void startDescTableRow()
Definition outputlist.h:632
OutputList::startMemberTemplateParams
void startMemberTemplateParams()
Definition outputlist.h:497
QCString
This is an alternative implementation of QCString.
Definition qcstring.h:103
QCString::find
int find(char c, int index=0, bool cs=TRUE) const
Definition qcstring.cpp:43
QCString::prepend
QCString & prepend(const char *s)
Definition qcstring.h:426
QCString::length
size_t length() const
Returns the length of the string, not counting the 0-terminator.
Definition qcstring.h:170
QCString::startsWith
bool startsWith(const char *s) const
Definition qcstring.h:511
QCString::mid
QCString mid(size_t index, size_t len=static_cast< size_t >(-1)) const
Definition qcstring.h:245
QCString::lower
QCString lower() const
Definition qcstring.h:253
QCString::endsWith
bool endsWith(const char *s) const
Definition qcstring.h:528
QCString::at
char & at(size_t i)
Returns a reference to the character at index i.
Definition qcstring.h:597
QCString::isEmpty
bool isEmpty() const
Returns TRUE iff the string is empty.
Definition qcstring.h:167
QCString::stripWhiteSpace
QCString stripWhiteSpace() const
returns a copy of this string with leading and trailing whitespace removed
Definition qcstring.h:264
QCString::remove
QCString & remove(size_t index, size_t len)
Definition qcstring.h:446
QCString::str
const std::string & str() const
Definition qcstring.h:556
QCString::simplifyWhiteSpace
QCString simplifyWhiteSpace() const
return a copy of this string with leading and trailing whitespace removed and multiple whitespace cha...
Definition qcstring.cpp:190
QCString::append
QCString & append(char c)
Definition qcstring.h:400
QCString::right
QCString right(size_t len) const
Definition qcstring.h:238
QCString::findRev
int findRev(char c, int index=-1, bool cs=TRUE) const
Definition qcstring.cpp:96
QCString::data
const char * data() const
Returns a pointer to the contents of the string in the form of a 0-terminated C string.
Definition qcstring.h:176
QCString::left
QCString left(size_t len) const
Definition qcstring.h:233
QCString::stripPrefix
bool stripPrefix(const QCString &prefix)
Definition qcstring.h:217
QCString::clear
void clear()
Definition qcstring.h:186
RequirementManager::instance
static RequirementManager & instance()
Definition requirement.cpp:96
RequirementManager::addRequirementRefsForSymbol
void addRequirementRefsForSymbol(const Definition *symbol)
Definition requirement.cpp:332
TextGeneratorOLImpl
Implements TextGeneratorIntf for an OutputDocInterface stream.
Definition util.h:76
TextStream
Text streaming class that buffers data.
Definition textstream.h:36
TypeSpecifier
Wrapper class for a number of boolean properties.
Definition types.h:694
VhdlDocGen::writeVHDLTypeDocumentation
static bool writeVHDLTypeDocumentation(const MemberDef *mdef, const Definition *d, OutputList &ol)
Definition vhdldocgen.cpp:1259
VhdlDocGen::writeSource
static void writeSource(const MemberDef *mdef, OutputList &ol, const QCString &cname)
Definition vhdldocgen.cpp:1849
VhdlDocGen::isMisc
static bool isMisc(const MemberDef *mdef)
Definition vhdldocgen.cpp:2502
toClassDefMutable
ClassDefMutable * toClassDefMutable(Definition *d)
Definition classdef.cpp:5506
getClass
ClassDef * getClass(const QCString &n)
Definition classdef.cpp:5523
toClassDef
ClassDef * toClassDef(Definition *d)
Definition classdef.cpp:5469
reg::Ex
Class representing a regular expression.
Definition regex.h:39
reg::Match
Object representing the matching results.
Definition regex.h:151
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
NON_COPYABLE
#define NON_COPYABLE(cls)
Macro to help implementing the rule of 5 for a non-copyable & movable class.
Definition construct.h:37
StringVector
std::vector< std::string > StringVector
Definition containers.h:33
stringToArgumentList
std::unique_ptr< ArgumentList > stringToArgumentList(SrcLangExt lang, const QCString &argsString, QCString *extraTypeChars=nullptr)
Definition defargs.l:826
toDefinition
Definition * toDefinition(DefinitionMutable *dm)
Definition definition.cpp:1989
AUTO_TRACE_ADD
#define AUTO_TRACE_ADD(...)
Definition docnode.cpp:49
AUTO_TRACE
#define AUTO_TRACE(...)
Definition docnode.cpp:48
docFindSections
void docFindSections(const QCString &input, const Definition *d, const QCString &fileName)
Definition docparser.cpp:2456
validatingParseDoc
IDocNodeASTPtr validatingParseDoc(IDocParser &parserIntf, const QCString &fileName, int startLine, const Definition *ctx, const MemberDef *md, const QCString &input, const DocOptions &options)
Definition docparser.cpp:2188
createDocParser
IDocParserPtr createDocParser()
factory function to create a parser
Definition docparser.cpp:55
setAnonymousEnumType
static void setAnonymousEnumType()
Definition doxygen.cpp:9067
writeTagFile
static void writeTagFile()
Definition doxygen.cpp:12105
addRequirementReferences
static void addRequirementReferences()
Definition doxygen.cpp:5584
toFileDef
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1966
toGroupDef
GroupDef * toGroupDef(Definition *d)
Definition groupdef.cpp:2082
theTranslator
Translator * theTranslator
Definition language.cpp:71
simplifyTypeForTable
static QCString simplifyTypeForTable(const QCString &s)
Definition memberdef.cpp:3969
writeExceptionList
static void writeExceptionList(OutputList &ol, const ClassDef *cd, const MemberDef *md)
Definition memberdef.cpp:1313
writeExceptionListImpl
static void writeExceptionListImpl(OutputList &ol, const ClassDef *cd, const MemberDef *md, QCString const &exception)
Definition memberdef.cpp:1273
stripTrailingReturn
static QCString stripTrailingReturn(const QCString &trailRet)
Definition memberdef.cpp:4205
combineArgsAndException
static QCString combineArgsAndException(QCString args, QCString exception)
Definition memberdef.cpp:2224
writeDefArgumentList
static bool writeDefArgumentList(OutputList &ol, const Definition *scope, const MemberDef *md)
Definition memberdef.cpp:1062
g_hasDetailedDescriptionMutex
static std::mutex g_hasDetailedDescriptionMutex
Definition memberdef.cpp:2672
g_docCrossReferenceMutex
static std::mutex g_docCrossReferenceMutex
Definition memberdef.cpp:6482
createMemberDefAlias
std::unique_ptr< MemberDef > createMemberDefAlias(const Definition *newScope, const MemberDef *aliasMd)
Definition memberdef.cpp:980
invalidateCachedTypesInArgumentList
static void invalidateCachedTypesInArgumentList(ArgumentList &al)
Definition memberdef.cpp:6145
g_detectUndocumentedParamsMutex
static std::mutex g_detectUndocumentedParamsMutex
Definition memberdef.cpp:4218
transferArgumentDocumentation
static void transferArgumentDocumentation(ArgumentList &decAl, ArgumentList &defAl)
Definition memberdef.cpp:6178
addDocCrossReference
void addDocCrossReference(const MemberDef *s, const MemberDef *d)
Definition memberdef.cpp:6484
g_cachedAnonymousTypeMutex
static std::mutex g_cachedAnonymousTypeMutex
Definition memberdef.cpp:1993
toMemberDefMutable
MemberDefMutable * toMemberDefMutable(Definition *d)
Definition memberdef.cpp:6574
combineDeclarationAndDefinition
void combineDeclarationAndDefinition(MemberDefMutable *mdec, MemberDefMutable *mdef)
Definition memberdef.cpp:6209
addTemplateNames
static QCString addTemplateNames(const QCString &s, const QCString &n, const QCString &t)
Definition memberdef.cpp:989
toMemberDef
MemberDef * toMemberDef(Definition *d)
Definition memberdef.cpp:6537
reAnonymous
static const reg::Ex reAnonymous(R"([\w:@]*@\d+)")
createMemberDef
std::unique_ptr< MemberDef > createMemberDef(const QCString &defFileName, int defLine, int defColumn, const QCString &type, const QCString &name, const QCString &args, const QCString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const QCString &metaData)
Factory method to create a new instance of a MemberDef.
Definition memberdef.cpp:524
warn_undoc
#define warn_undoc(file, line, fmt,...)
Definition message.h:102
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
warn_doc_error
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
toModuleDef
ModuleDef * toModuleDef(Definition *d)
Definition moduledef.cpp:1202
toNamespaceDef
NamespaceDef * toNamespaceDef(Definition *d)
Definition namespacedef.cpp:1696
reg::search
bool search(std::string_view str, Match &match, const Ex &re, size_t pos)
Search in a given string str starting at position pos for a match against regular expression re.
Definition regex.cpp:844
substitute
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:571
qsnprintf
#define qsnprintf
Definition qcstring.h:49
TRUE
#define TRUE
Definition qcstring.h:37
FALSE
#define FALSE
Definition qcstring.h:34
qstrlen
uint32_t qstrlen(const char *str)
Returns the length of string str, or 0 if a null pointer is passed.
Definition qcstring.h:58
ASSERT
#define ASSERT(x)
Definition qcstring.h:39
RefItemVector
std::vector< RefItem * > RefItemVector
Definition reflist.h:133
searchindex.h
Web server based search engine.
stripWhiteSpace
std::string_view stripWhiteSpace(std::string_view s)
Given a string view s, returns a new, narrower view on that string, skipping over any leading or trai...
Definition stringutil.h:72
Argument
This class contains the information about the argument of a function or template.
Definition arguments.h:27
Argument::type
QCString type
Definition arguments.h:42
Argument::name
QCString name
Definition arguments.h:44
Argument::defval
QCString defval
Definition arguments.h:46
Argument::docs
QCString docs
Definition arguments.h:47
Argument::array
QCString array
Definition arguments.h:45
Argument::attrib
QCString attrib
Definition arguments.h:41
CodeParserOptions
Options to configure the code parser.
Definition parserintf.h:78
Example
Data associated with an example.
Definition example.h:29
Grouping::GroupPri_t
GroupPri_t
Grouping priority.
Definition types.h:230
Grouping::GROUPING_AUTO_DEF
@ GROUPING_AUTO_DEF
membership in group was defined via @defgroup
Definition types.h:234
LinkifyTextOptions
Definition util.h:96
LinkifyTextOptions::setScope
LinkifyTextOptions & setScope(const Definition *scope)
Definition util.h:110
LinkifyTextOptions::setSelf
LinkifyTextOptions & setSelf(const Definition *self)
Definition util.h:116
LinkifyTextOptions::setFileScope
LinkifyTextOptions & setFileScope(const FileDef *fileScope)
Definition util.h:113
TagInfo
This struct is used to capture the tag file information for an Entry.
Definition entry.h:104
TagInfo::anchor
QCString anchor
Definition entry.h:107
TagInfo::fileName
QCString fileName
Definition entry.h:106
TagInfo::tagName
QCString tagName
Definition entry.h:105
CodeSymbolType
CodeSymbolType
Definition types.h:481
MemberType
MemberType
Definition types.h:569
MemberListContainer
MemberListContainer
Definition types.h:472
Protection
Protection
Definition types.h:32
SrcLangExt
SrcLangExt
Definition types.h:207
Relationship
Relationship
Definition types.h:167
Specifier
Specifier
Definition types.h:80
to_string_lower
static constexpr const char * to_string_lower(Protection prot) noexcept
Definition types.h:50
VhdlSpecifier
VhdlSpecifier
Definition types.h:770
matchArguments2
bool matchArguments2(const Definition *srcScope, const FileDef *srcFileScope, const QCString &srcReturnType, const ArgumentList *srcAl, const Definition *dstScope, const FileDef *dstFileScope, const QCString &dstReturnType, const ArgumentList *dstAl, bool checkCV, SrcLangExt lang)
Definition util.cpp:2031
removeRedundantWhiteSpace
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:567
getLanguageFromFileName
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5231
protectionLevelVisible
bool protectionLevelVisible(Protection prot)
Definition util.cpp:5955
substituteTemplateArgumentsInString
QCString substituteTemplateArgumentsInString(const QCString &nm, const ArgumentList &formalArgs, const ArgumentList *actualArgs)
Definition util.cpp:4386
stripIndentationVerbatim
void stripIndentationVerbatim(QCString &doc, const int indentationLevel, bool skipFirstLine)
Definition util.cpp:6056
writeTypeConstraints
void writeTypeConstraints(OutputList &ol, const Definition *d, const ArgumentList &al)
Definition util.cpp:5479
stripAnonymousNamespaceScope
QCString stripAnonymousNamespaceScope(const QCString &s)
Definition util.cpp:230
stripFromIncludePath
QCString stripFromIncludePath(const QCString &path)
Definition util.cpp:329
tempArgListToString
QCString tempArgListToString(const ArgumentList &al, SrcLangExt lang, bool includeDefault)
Definition util.cpp:1299
addRefItem
void addRefItem(const RefItemVector &sli, const QCString &key, const QCString &prefix, const QCString &name, const QCString &title, const QCString &args, const Definition *scope)
Definition util.cpp:4845
writePageRef
void writePageRef(OutputList &ol, const QCString &cn, const QCString &mn)
Definition util.cpp:259
removeAnonymousScopes
QCString removeAnonymousScopes(const QCString &str)
Definition util.cpp:161
inlineTemplateArgListToDoc
QCString inlineTemplateArgListToDoc(const ArgumentList &al)
Definition util.cpp:1227
stripExtension
QCString stripExtension(const QCString &fName)
Definition util.cpp:4964
convertToXML
QCString convertToXML(const QCString &s, bool keepEntities)
Definition util.cpp:3933
detab
QCString detab(const QCString &s, size_t &refIndent)
Definition util.cpp:6738
getLanguageSpecificSeparator
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:5915
mergeMemberOverrideOptions
void mergeMemberOverrideOptions(MemberDefMutable *md1, MemberDefMutable *md2)
Definition util.cpp:6879
linkifyText
void linkifyText(const TextGeneratorIntf &out, const QCString &text, const LinkifyTextOptions &options)
Definition util.cpp:893
writeMarkerList
void writeMarkerList(OutputList &ol, const std::string &markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)
Definition util.cpp:1124
inlineArgListToDoc
QCString inlineArgListToDoc(const ArgumentList &al)
Definition util.cpp:1204
writeExamples
void writeExamples(OutputList &ol, const ExampleList &list)
Definition util.cpp:1175
addHtmlExtensionIfMissing
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:4942
util.h
A bunch of utility functions.
isId
bool isId(int c)
Definition util.h:256