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