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