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