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