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