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