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 bool forceLocalIncludes = Config_getBool(FORCE_LOCAL_INCLUDES);
3391 const FileDef *fd = getFileDef();
3392 QCString nm;
3393 if (inGroup && fd && showGroupedMembInc)
3394 {
3395 if (!Config_getList(STRIP_FROM_INC_PATH).empty())
3396 {
3398 }
3399 else
3400 {
3401 nm = fd->name();
3402 }
3403 }
3404 if (!nm.isEmpty())
3405 {
3406 ol.startParagraph();
3407 ol.startTypewriter();
3408 SrcLangExt lang = getLanguage();
3409 bool isIDLorJava = lang==SrcLangExt::IDL || lang==SrcLangExt::Java;
3410 if (isIDLorJava)
3411 {
3412 ol.docify("import ");
3413 }
3414 else
3415 {
3416 ol.docify("#include ");
3417 }
3418
3419 if (isIDLorJava || forceLocalIncludes) ol.docify("\""); else ol.docify("<");
3420
3421 if (fd->isLinkable())
3422 {
3423 ol.writeObjectLink(fd->getReference(),fd->getOutputFileBase(),fd->anchor(),nm);
3424 }
3425 else
3426 {
3427 ol.docify(nm);
3428 }
3429
3430 if (isIDLorJava || forceLocalIncludes) ol.docify("\""); else ol.docify(">");
3431
3432 ol.endTypewriter();
3433 ol.endParagraph();
3434 }
3435}
3436
3438{
3439 //printf("md=%s initLines=%d init='%s'\n",qPrint(name()),initLines,qPrint(init));
3440 ol.startBold();
3442 ol.parseText(theTranslator->trDefineValue());
3443 else
3444 ol.parseText(theTranslator->trInitialValue());
3445 ol.endBold();
3446 QCString langCorrected = getDefFileExtension();
3448 if (srcLangExt == SrcLangExt::Lex)
3449 {
3450 langCorrected = ".doxygen_lex_c";
3451 srcLangExt = SrcLangExt::Cpp;
3452 }
3453 auto intf = Doxygen::parserManager->getCodeParser(langCorrected);
3454 intf->resetCodeParserState();
3455 auto &codeOL = ol.codeGenerators();
3456 codeOL.startCodeFragment("DoxyCode");
3457 intf->parseCode(codeOL,scopeName,m_initializer,srcLangExt,Config_getBool(STRIP_CODE_COMMENTS),FALSE,QCString(),getFileDef(),
3458 -1,-1,TRUE,this,FALSE,this);
3459 codeOL.endCodeFragment("DoxyCode");
3460}
3461
3462/*! Writes the "detailed documentation" section of this member to
3463 * all active output formats.
3464 */
3466 int memCount,int memTotal,
3467 OutputList &ol,
3468 const QCString &scName,
3469 const Definition *container,
3470 bool inGroup,
3471 bool /* showEnumValues */,
3472 bool showInline
3473 ) const
3474{
3475 // if this member is in a group find the real scope name.
3476 bool hasParameterList = FALSE;
3477
3478 //printf("MemberDefImpl::writeDocumentation(): name='%s' hasDocs='%d' containerType=%d inGroup=%d sectionLinkable=%d\n",
3479 // qPrint(name()),hasDocs,container->definitionType(),inGroup,hasDetailedDescription());
3480
3481 //if ( !hasDocs ) return;
3482 //if (isEnumValue() && !showEnumValues) return;
3483
3484 SrcLangExt lang = getLanguage();
3485 //printf("member=%s lang=%d\n",qPrint(name()),lang);
3486 bool optVhdl = lang==SrcLangExt::VHDL;
3488
3489 QCString scopeName = scName;
3490 QCString memAnchor = anchor();
3491 QCString ciname = container->displayName();
3492 const Definition *scopedContainer = container; // see bug 753608
3493 if (container->definitionType()==TypeGroup)
3494 {
3495 if (getClassDef()) { scopeName=getClassDef()->displayName(); scopedContainer=getClassDef(); }
3496 else if (getNamespaceDef()) { scopeName=getNamespaceDef()->displayName(); scopedContainer=getNamespaceDef(); }
3497 else if (getFileDef()) { scopeName=getFileDef()->displayName(); scopedContainer=getFileDef(); }
3498 ciname = (toGroupDef(container))->groupTitle();
3499 }
3500 else if (container->definitionType()==TypeFile && getNamespaceDef() && getNamespaceDef()->isLinkable())
3501 { // member is in a namespace, but is written as part of the file documentation
3502 // as well, so we need to make sure its anchor is unique (it is not really used).
3503 memAnchor.prepend("file_");
3504 }
3505
3506 QCString cname = container->name();
3507 QCString cfname = getOutputFileBase();
3508
3509 // get member name
3510 QCString doxyName=name();
3511 // prepend scope if there is any. TODO: make this optional for C only docs
3512 if (!scopeName.isEmpty())
3513 {
3514 doxyName.prepend(scopeName+sep);
3515 }
3516 QCString doxyArgs=argsString();
3517
3518 QCString ldef = definition();
3519 QCString title = name();
3520 //printf("member '%s' def='%s'\n",qPrint(name()),qPrint(ldef));
3521 if (isEnumerate())
3522 {
3523 if (title.at(0)=='@')
3524 {
3525 ldef = title = "anonymous enum";
3526 if (!m_enumBaseType.isEmpty())
3527 {
3528 ldef+=" : "+m_enumBaseType;
3529 }
3530 }
3531 else
3532 {
3533 if (lang==SrcLangExt::Cpp)
3534 {
3535 if (isEnumStruct()) ldef.prepend("struct ");
3536 else if (isStrong()) ldef.prepend("class ");
3537 }
3538 ldef.prepend("enum ");
3539 if (isSliceLocal())
3540 {
3541 ldef.prepend("local ");
3542 }
3543 }
3544 }
3545 else if (isEnumValue())
3546 {
3547 if (ldef.at(0)=='@')
3548 {
3549 ldef=ldef.mid(2);
3550 }
3551 }
3552 else if (isFunction() && !isObjCMethod())
3553 {
3554 title += "()";
3555 }
3556 if (lang == SrcLangExt::Slice)
3557 {
3558 // Remove the container scope from the member name.
3559 QCString prefix = scName + sep;
3560 int pos = ldef.findRev(prefix.data());
3561 if(pos != -1)
3562 {
3563 ldef.remove(pos, prefix.length());
3564 }
3565 }
3566 ldef.stripPrefix("constexpr ");
3567 ldef.stripPrefix("consteval ");
3568 ldef.stripPrefix("constinit ");
3569 ldef.stripPrefix("static ");
3570
3571 //----------------------------------------
3572
3573 ol.pushGeneratorState();
3574
3575 bool htmlEndLabelTable=FALSE;
3576 StringVector sl = getLabels(scopedContainer);
3577
3578 static const reg::Ex r(R"(@\d+)");
3579 reg::Match match;
3580 std::string sdef = ldef.str();
3581 if ((isVariable() || isTypedef()) && reg::search(sdef,match,r))
3582 {
3583 // find enum type and insert it in the definition
3584 bool found=false;
3585 for (const auto &vmd : *ml)
3586 {
3587 if (vmd->isEnumerate() && match.str()==vmd->name())
3588 {
3589 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3590 ol.startMemberDoc(ciname,name(),memAnchor,name(),memCount,memTotal,showInline);
3591 ol.addLabel(cfname, memAnchor);
3592 QCString prefix = match.prefix().str();
3593 QCString suffix = match.suffix().str();
3594 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,prefix);
3595 vmd->writeEnumDeclaration(ol,getClassDef(),getNamespaceDef(),getFileDef(),getGroupDef(),getModuleDef());
3596 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,suffix);
3597
3598 found=true;
3599 break;
3600 }
3601 }
3602 if (!found) // anonymous compound
3603 {
3604 ClassDef *annoClassDef=getClassDefOfAnonymousType();
3605 QCString typeName;
3606 if (annoClassDef) typeName=annoClassDef->compoundTypeString();
3607 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3608 ol.startMemberDoc(ciname,name(),memAnchor,"["+typeName+"]",memCount,memTotal,showInline);
3609 ol.addLabel(cfname, memAnchor);
3610 // search for the last anonymous compound name in the definition
3611
3613 if (reg::search(sdef,match,reAnonymous))
3614 {
3615 QCString prefix = match.prefix().str();
3616 QCString suffix = match.suffix().str();
3617 ol.docify(prefix);
3618 ol.docify(" { ... } ");
3619 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,removeAnonymousScopes(suffix));
3620 }
3621 else
3622 {
3623 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,ldef);
3624 }
3625 }
3626 }
3627 else // not an enum value or anonymous compound
3628 {
3629 ol.startDoxyAnchor(cfname, cname, memAnchor, doxyName, doxyArgs);
3630 ol.startMemberDoc(ciname,name(),memAnchor,title,memCount,memTotal,showInline);
3631 ol.addLabel(cfname, memAnchor);
3632
3633 if (!m_metaData.isEmpty() && getLanguage()==SrcLangExt::Slice)
3634 {
3636 ol.docify(m_metaData);
3638 }
3639
3640 const ClassDef *cd=getClassDef();
3641 const NamespaceDef *nd=getNamespaceDef();
3642 if (!m_defTmpArgLists.empty() && lang==SrcLangExt::Cpp)
3643 // definition has explicit template parameter declarations
3644 {
3645 for (const ArgumentList &tal : m_defTmpArgLists)
3646 {
3647 if (!tal.empty())
3648 {
3650 _writeTemplatePrefix(ol,scopedContainer,tal);
3652 }
3653 }
3654 }
3655 else // definition gets it template parameters from its class
3656 // (since no definition was found)
3657 {
3658 if (cd && lang==SrcLangExt::Cpp && !isTemplateSpecialization())
3659 {
3660 for (const ArgumentList &tal : cd->getTemplateParameterLists())
3661 {
3662 if (!tal.empty())
3663 {
3665 _writeTemplatePrefix(ol,scopedContainer,tal,false);
3667 }
3668 }
3669 }
3670 if (m_tArgList.hasParameters() && lang==SrcLangExt::Cpp) // function template prefix
3671 {
3673 _writeTemplatePrefix(ol,scopedContainer,m_tArgList);
3675 }
3676 }
3677
3678 if (!sl.empty())
3679 {
3680 ol.pushGeneratorState();
3681 ol.disableAll();
3683 ol.writeString("<table class=\"mlabels\">\n");
3684 ol.writeString(" <tr>\n");
3685 ol.writeString(" <td class=\"mlabels-left\">\n");
3686 ol.popGeneratorState();
3687 htmlEndLabelTable=TRUE;
3688 }
3689
3691 if (cd && cd->isObjectiveC())
3692 {
3693 // strip scope name
3694 int ep = ldef.find("::");
3695 if (ep!=-1)
3696 {
3697 int sp=ldef.findRev(' ',ep);
3698 if (sp!=-1)
3699 {
3700 ldef=ldef.left(sp+1)+ldef.mid(ep+2);
3701 } else {
3702 ldef=ldef.mid(ep+2);
3703 }
3704 }
3705 // strip keywords
3706 int dp = ldef.find(':');
3707 if (dp!=-1)
3708 {
3709 ldef=ldef.left(dp+1);
3710 }
3711 int dl=static_cast<int>(ldef.length());
3712 //printf("start >%s<\n",qPrint(ldef));
3713 int i=dl-1;
3714 while (i>=0 && (isId(ldef.at(i)) || ldef.at(i)==':')) i--;
3715 while (i>=0 && isspace(static_cast<uint8_t>(ldef.at(i)))) i--;
3716 if (i>0)
3717 {
3718 // insert branches around the type
3719 ldef="("+ldef.left(i+1)+")"+ldef.mid(i+1);
3720 }
3721 //printf("end >%s< i=%d\n",qPrint(ldef),i);
3722 if (isStatic()) ldef.prepend("+ "); else ldef.prepend("- ");
3723 }
3724
3725 if (optVhdl)
3726 {
3727 hasParameterList=VhdlDocGen::writeVHDLTypeDocumentation(this,scopedContainer,ol);
3728 }
3729 else if (lang==SrcLangExt::Slice)
3730 {
3731 // Eliminate the self-reference.
3732 int pos = ldef.findRev(' ');
3733 if (pos<0) pos=0;
3734 if (pos>0)
3735 {
3737 scopedContainer,
3738 getBodyDef(),
3739 this,
3740 ldef.left(pos)
3741 );
3742 }
3743 ol.docify(ldef.mid(pos));
3744 const Definition *scope = cd;
3745 if (scope==nullptr) scope = nd;
3746 hasParameterList=writeDefArgumentList(ol,scope,this);
3747 }
3748 else
3749 {
3751 scopedContainer,
3752 getBodyDef(),
3753 this,
3754 substitute(ldef,"::",sep)
3755 );
3756 const Definition *scope = cd;
3757 if (scope==nullptr) scope = nd;
3758 hasParameterList=writeDefArgumentList(ol,scope,this);
3759 }
3760
3761 if (hasOneLineInitializer()) // add initializer
3762 {
3763 if (isTypeAlias())
3764 {
3765 ol.docify(" = ");
3766 QCString init = m_initializer.simplifyWhiteSpace();
3767 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,init);
3768 }
3769 else if (!isDefine())
3770 {
3771 ol.docify(" ");
3772 QCString init = m_initializer.simplifyWhiteSpace();
3773 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,init);
3774 }
3775 else
3776 {
3778 linkifyText(TextGeneratorOLImpl(ol),scopedContainer,getBodyDef(),this,m_initializer);
3779 }
3780 }
3781 if (!excpString().isEmpty()) // add exception list
3782 {
3783 writeExceptionList(ol,cd,this);
3784 hasParameterList=true; // call endParameterList below
3785 }
3786 }
3787
3788 ol.pushGeneratorState();
3790 if (!sl.empty())
3791 {
3792 ol.startLabels();
3793 size_t count=0;
3794 for (const auto &s : sl)
3795 {
3796 count++;
3797 ol.writeLabel(s,count==sl.size());
3798 }
3799 ol.endLabels();
3800 }
3801 ol.popGeneratorState();
3802
3803 if (hasParameterList)
3804 {
3805 ol.endParameterList();
3806 ol.endMemberDoc(TRUE);
3807 }
3808 else
3809 {
3810 ol.endMemberDocName();
3811 ol.endMemberDoc(FALSE);
3812 }
3813
3814 // for HTML write the labels here
3815 ol.pushGeneratorState();
3816 ol.disableAll();
3818 if (htmlEndLabelTable)
3819 {
3820 ol.writeString(" </td>\n");
3821 ol.writeString(" <td class=\"mlabels-right\">\n");
3822 ol.startLabels();
3823 size_t count=0;
3824 for (const auto &s : sl)
3825 {
3826 count++;
3827 ol.writeLabel(s,count==sl.size());
3828 }
3829 ol.endLabels();
3830 ol.writeString(" </td>\n");
3831 ol.writeString(" </tr>\n");
3832 ol.writeString("</table>\n");
3833 }
3834 ol.writeString("</div>");
3835 ol.popGeneratorState();
3836
3837
3838 ol.endDoxyAnchor(cfname,memAnchor);
3839 ol.startIndent();
3840
3841 _writeGroupInclude(ol,inGroup);
3842
3843 /* write multi-line initializer (if any) */
3845
3846 /* write brief description */
3847 QCString brief = briefDescription();
3848 if (!brief.isEmpty() &&
3849 (Config_getBool(REPEAT_BRIEF) ||
3850 !Config_getBool(BRIEF_MEMBER_DESC)
3851 )
3852 )
3853 {
3854 ol.startParagraph();
3856 briefLine(),
3857 scopedContainer,
3858 this,
3859 brief,
3860 DocOptions()
3861 .setSingleLine(true));
3862 ol.endParagraph();
3863 }
3864
3865 /* write detailed description */
3866 QCString detailed = documentation();
3867 if (!detailed.isEmpty() ||
3868 !inbodyDocumentation().isEmpty())
3869 {
3870 // write vhdl inline code with or without option INLINE_SOURCE
3871 if (optVhdl && VhdlDocGen::isMisc(this))
3872 {
3873 VhdlDocGen::writeSource(this,ol,cname);
3874 return;
3875 }
3876 else
3877 {
3878 ol.generateDoc(docFile(),
3879 docLine(),
3880 scopedContainer,
3881 this,
3882 detailed+"\n",
3883 DocOptions()
3884 .setIndexWords(true));
3885 }
3886
3887 if (!inbodyDocumentation().isEmpty())
3888 {
3890 inbodyLine(),
3891 scopedContainer,
3892 this,
3893 inbodyDocumentation()+"\n",
3894 DocOptions()
3895 .setIndexWords(true));
3896 }
3897 }
3898 else if (!brief.isEmpty() && (Config_getBool(REPEAT_BRIEF) || !Config_getBool(BRIEF_MEMBER_DESC)))
3899 {
3900 if (!inbodyDocumentation().isEmpty())
3901 {
3903 inbodyLine(),
3904 scopedContainer,
3905 this,
3906 inbodyDocumentation()+"\n",
3907 DocOptions()
3908 .setIndexWords(true));
3909 }
3910 }
3911
3912
3913 //printf("***** defArgList=%p name=%s docs=%s hasDocs=%d\n",
3914 // defArgList,
3915 // defArgList?defArgList->hasDocumentation():-1);
3916 const ArgumentList &docArgList = m_templateMaster ?
3917 m_templateMaster->argumentList() :
3919 ol.generateDoc(docFile(),
3920 docLine(),
3921 scopedContainer,
3922 this, // memberDef
3923 inlineArgListToDoc(docArgList), // docStr
3924 DocOptions()
3925 .setIndexWords(true));
3926
3927 const ArgumentList &docTemplateArgList = m_templateMaster ?
3928 m_templateMaster->templateArguments() :
3929 m_tArgList;
3930 ol.generateDoc(docFile(),
3931 docLine(),
3932 scopedContainer,
3933 this, // memberDef
3934 inlineTemplateArgListToDoc(docTemplateArgList), // docStr
3935 DocOptions()
3936 .setIndexWords(true));
3937
3938 _writeEnumValues(ol,scopedContainer,cfname,ciname,cname);
3942 _writeExamples(ol);
3944 QCString scopeStr = getScopeString();
3945 writeSourceDef(ol);
3946 writeInlineCode(ol,scopeStr);
3947 if (hasReferencesRelation()) writeSourceRefs(ol,scopeStr);
3948 if (hasReferencedByRelation()) writeSourceReffedBy(ol,scopeStr);
3949 _writeCallGraph(ol);
3951
3952 ol.endIndent();
3953
3954 // enable LaTeX again
3955 //if (Config_getBool(EXTRACT_ALL) && !hasDocs) ol.enable(OutputType::Latex);
3956 ol.popGeneratorState();
3957
3959}
3960
3961// strip scope and field name from the type
3962// example: "struct N<K::J>::S.v.c" will become "struct v"
3964{
3966 if (ts.endsWith("::")) ts = ts.left(ts.length()-2);
3967 static const reg::Ex re1(R"(\a\w*::)"); // non-template version
3968 static const reg::Ex re2(R"(\a\w*<[^>]*>::)"); // template version
3969 reg::Match match;
3970 std::string t = ts.str();
3971 while (reg::search(t,match,re2) || reg::search(t,match,re1))
3972 {
3973 t = match.prefix().str() + match.suffix().str(); // remove the matched part
3974 }
3975 //printf("simplifyTypeForTable(%s)->%s\n",qPrint(s),qPrint(t));
3976 return t;
3977}
3978
3980{
3981 QCString type = m_accessorType;
3982 if (type.isEmpty())
3983 {
3984 type = m_type;
3985 }
3986
3987 if (isTypedef() && getLanguage() != SrcLangExt::Slice) type.prepend("typedef ");
3988 return simplifyTypeForTable(type);
3989}
3990
3992{
3993 Definition *scope = getOuterScope();
3994 QCString doxyName = name();
3995 QCString doxyArgs = argsString();
3996 QCString memAnchor = anchor();
3997 QCString cfname = getOutputFileBase();
3998 QCString cname;
3999 if (scope) cname = scope->name();
4000 if (doxyName.at(0)=='@')
4001 {
4002 doxyName="__unnamed__";
4003 }
4004
4006 //printf("===> %s::anonymous: %s\n",qPrint(name()),cd?qPrint(cd->name()):"<none>");
4007
4008 if (container && container->definitionType()==Definition::TypeClass &&
4009 !(toClassDef(container))->isJavaEnum())
4010 {
4012 ol.startDoxyAnchor(cfname,cname,memAnchor,doxyName,doxyArgs);
4013 ol.addLabel(cfname,memAnchor);
4014
4015 QCString ts = fieldType();
4016
4017 if (isFunctionPtr())
4018 ts = m_type + m_args;
4019
4020 if (cd) // cd points to an anonymous struct pointed to by this member
4021 // so we add a link to it from the type column.
4022 {
4023 int i=0;
4024 const char *prefixes[] = { "struct ","union ","class ", nullptr };
4025 const char **p = prefixes;
4026 while (*p)
4027 {
4028 int l=qstrlen(*p);
4029 if (ts.left(l)==*p)
4030 {
4031 ol.writeString(*p);
4032 i=l;
4033 }
4034 p++;
4035 }
4037 cd->getOutputFileBase(),
4038 cd->anchor(),ts.mid(i));
4039 }
4040 else // use standard auto linking
4041 {
4043 scope, // scope
4044 getBodyDef(), // fileScope
4045 this, // self
4046 ts // text
4047 );
4048 }
4049 ol.endDoxyAnchor(cfname,memAnchor);
4051 }
4052
4054 ol.docify(doxyName);
4055 if (isVariable() && !argsString().isEmpty() && !isObjCMethod() && !isFunctionPtr())
4056 {
4058 }
4059 if (!m_bitfields.isEmpty()) // add bitfields
4060 {
4062 }
4063 if (hasOneLineInitializer() && !isDefine())
4064 {
4065 ol.writeString(" ");
4066 linkifyText(TextGeneratorOLImpl(ol),getOuterScope(),getBodyDef(),this,m_initializer.simplifyWhiteSpace());
4067 }
4069
4071
4072 QCString brief = briefDescription();
4073 QCString detailed = documentation();
4074
4075 /* write brief description */
4076 if (!brief.isEmpty())
4077 {
4079 briefLine(),
4080 getOuterScope()?getOuterScope():container,this,
4081 brief,
4082 DocOptions()
4083 .setSingleLine(true));
4084 }
4085
4086 /* write detailed description */
4087 if (!detailed.isEmpty())
4088 {
4089 if (!brief.isEmpty())
4090 {
4092 ol.lineBreak();
4094 }
4095 ol.generateDoc(docFile(),
4096 docLine(),
4097 getOuterScope()?getOuterScope():container,this,
4098 detailed+"\n",
4099 DocOptions());
4100 }
4101
4102 ol.endInlineMemberDoc();
4103}
4104
4106{
4107 switch (m_mtype)
4108 {
4109 case MemberType::Define: return "macro definition";
4110 case MemberType::Function: return "function";
4111 case MemberType::Variable: return "variable";
4112 case MemberType::Typedef: return "typedef";
4113 case MemberType::Enumeration: return "enumeration";
4114 case MemberType::EnumValue: return "enumvalue";
4115 case MemberType::Signal: return "signal";
4116 case MemberType::Slot: return "slot";
4117 case MemberType::Friend: return "friend";
4118 case MemberType::DCOP: return "dcop";
4119 case MemberType::Property: return "property";
4120 case MemberType::Event: return "event";
4121 case MemberType::Interface: return "interface";
4122 case MemberType::Service: return "service";
4123 case MemberType::Sequence: return "sequence";
4124 case MemberType::Dictionary: return "dictionary";
4125 default: return "unknown";
4126 }
4127}
4128
4130{
4131 /*
4132 * Removed bug_303020:
4133 * if (m_memberGroup) return;
4134 */
4135 const ClassDef *cd = getClassDef();
4136 const NamespaceDef *nd = getNamespaceDef();
4137 const FileDef *fd = getFileDef();
4138 const GroupDef *gd = getGroupDef();
4139 const Definition *d=nullptr;
4140 QCString t;
4141 if (cd)
4142 {
4143 t=cd->compoundTypeString();
4144 d=cd;
4145 }
4146 else if (nd)
4147 {
4148 t=nd->compoundTypeString();
4149 d=nd;
4150 }
4151 else if (gd)
4152 {
4153 t="group";
4154 d=gd;
4155 }
4156 else
4157 {
4158 t="file";
4159 d=fd;
4160 }
4161 bool extractAll = Config_getBool(EXTRACT_ALL);
4162
4163 //printf("%s:warnIfUndoc: hasUserDocs=%d isFriendClass=%d protection=%d isRef=%d isDel=%d\n",
4164 // qPrint(name()),
4165 // hasUserDocumentation(),isFriendClass(),protectionLevelVisible(m_prot),isReference(),isDeleted());
4166 if ((!hasUserDocumentation() && !extractAll) &&
4167 !isFriendClass() &&
4168 name().find('@')==-1 && d && d->name().find('@')==-1 &&
4171 !isReference() && !isDeleted()
4172 )
4173 {
4174 SrcLangExt lang = getLanguage();
4176 warn_undoc(getDefFileName(),getDefLine(),"Member {}{} ({}) of {} {} is not documented.",
4178 substitute(d->name(),"::",sep));
4179 }
4180 else if (!hasDetailedDescription())
4181 {
4183 }
4184
4185 // if it is an enum, we check that its members are documented
4186 if (!extractAll && isEnumerate() && Config_getBool(WARN_IF_UNDOC_ENUM_VAL))
4187 {
4188 for (const auto &fmd : enumFieldList())
4189 {
4190 if (!fmd->isLinkableInProject())
4191 {
4192 SrcLangExt lang = getLanguage();
4194 warn(fmd->getDefFileName(),fmd->getDefLine(), "Documentation for enum member '{}{}{}' is missing.",
4195 qualifiedName(),sep,fmd->name());
4196 }
4197 }
4198 }
4199}
4200
4202{
4203 bool hideUndocMembers = Config_getBool(HIDE_UNDOC_MEMBERS);
4204 bool extractStatic = Config_getBool(EXTRACT_STATIC);
4205 return (!isAnonymous() &&
4206 (!hideUndocMembers || hasDocumentation()) &&
4207 (!isStatic() || extractStatic) &&
4208 isLinkable()
4209 );
4210}
4211
4213{
4214 QCString ret = trailRet;
4215
4216 ret = ret.stripWhiteSpace();
4217 if (ret.startsWith("->"))
4218 {
4219 ret = ret.mid(2).stripWhiteSpace();
4220 return ret;
4221 }
4222 return trailRet;
4223}
4224
4226
4227void MemberDefImpl::detectUndocumentedParams(bool hasParamCommand,bool hasReturnCommand) const
4228{
4229 //printf("%s:detectUndocumentedParams(%d,%d)\n",qPrint(name()),hasParamCommand,hasReturnCommand);
4230 bool isPython = getLanguage()==SrcLangExt::Python;
4231
4232 // this function is called while parsing the documentation. A member can have multiple
4233 // documentation blocks, which could be handled by multiple threads, hence this guard.
4234 std::lock_guard<std::mutex> lock(g_detectUndocumentedParamsMutex);
4235
4236 if (!m_hasDocumentedParams && hasParamCommand)
4237 {
4238 //printf("%s:hasDocumentedParams=TRUE;\n",qPrint(name()));
4239 m_hasDocumentedParams = true;
4240 }
4241 else if (!m_hasDocumentedParams)
4242 {
4243 const ArgumentList &al = argumentList();
4244 const ArgumentList &declAl = declArgumentList();
4245 bool allDoc=TRUE; // no parameter => all parameters are documented
4246 if ( // member has parameters
4247 al.hasParameters() // with at least one parameter (that is not void)
4248 )
4249 {
4250 // see if all parameters have documentation
4251 for (auto it = al.begin(); it!=al.end() && allDoc; ++it)
4252 {
4253 const Argument &a = *it;
4254 if (!a.name.isEmpty() && a.type!="void" && a.name!="..." &&
4255 !(isPython && (a.name=="self" || a.name=="cls"))
4256 )
4257 {
4258 allDoc = !a.docs.isEmpty();
4259 }
4260 //printf("a.type=%s a.name=%s doc=%s\n",
4261 // qPrint(a.type),qPrint(a.name),qPrint(a.docs));
4262 }
4263 if (!allDoc && declAl.empty()) // try declaration arguments as well
4264 {
4265 allDoc=true;
4266 for (auto it = al.begin(); it!=al.end() && allDoc; ++it)
4267 {
4268 const Argument &a = *it;
4269 if (!a.name.isEmpty() && a.type!="void" && a.name!="..." &&
4270 !(isPython && (a.name=="self" || a.name=="cls"))
4271 )
4272 {
4273 allDoc = !a.docs.isEmpty();
4274 }
4275 //printf("a.name=%s doc=%s\n",qPrint(a.name),qPrint(a.docs));
4276 }
4277 }
4278 }
4279 if (allDoc)
4280 {
4281 //printf("%s:hasDocumentedParams=TRUE;\n",qPrint(name()));
4282 m_hasDocumentedParams = true;
4283 }
4284 }
4285
4286 //printf("Member %s hasDocumentedReturnType=%d hasReturnCommand=%d\n",
4287 // qPrint(name()),m_hasDocumentedReturnType,hasReturnCommand);
4289}
4290
4292{
4293 QCString returnType = typeString();
4294 bool isFortran = getLanguage()==SrcLangExt::Fortran;
4295 bool isFortranSubroutine = isFortran && returnType.find("subroutine")!=-1;
4296
4297 bool isVoidReturn = returnType=="void" || returnType.endsWith(" void");
4298 if (!isVoidReturn && (returnType=="auto" || returnType.endsWith(" auto")))
4299 {
4301 if (!defArgList.trailingReturnType().isEmpty())
4302 {
4303 QCString strippedTrailingReturn = stripTrailingReturn(defArgList.trailingReturnType());
4304 isVoidReturn = (strippedTrailingReturn=="void") || (strippedTrailingReturn.endsWith(" void"));
4305 }
4306 }
4307 if (!Config_getBool(EXTRACT_ALL) &&
4308 Config_getBool(WARN_IF_UNDOCUMENTED) &&
4309 Config_getBool(WARN_NO_PARAMDOC) &&
4310 isFunction() &&
4311 !isDeleted() &&
4312 !isReference() &&
4314 {
4316 {
4318 "parameters of member {} are not documented",
4319 qualifiedName());
4320 }
4322 hasDocumentation() && !returnType.isEmpty() &&
4323 !( // not one of the cases where nothing is returned
4324 isVoidReturn || // void return type
4325 isFortranSubroutine || // fortran subroutine
4326 isConstructor() || // a constructor
4327 isDestructor() || // or a destructor
4328 isFriend() // or a friend
4329 )
4330 )
4331 {
4333 "return type of member {} is not documented",
4334 qualifiedName());
4335 }
4336 }
4337 if (Config_getBool(WARN_IF_DOC_ERROR) &&
4339 (isVoidReturn || // void return type
4340 isFortranSubroutine || // fortran subroutine
4341 isConstructor() || // a constructor
4342 isDestructor())) // or destructor
4343 {
4344 warn_doc_error(docFile(),docLine(),"found documented return type for {} that does not return anything",
4345 qualifiedName());
4346 }
4347}
4348
4350{
4351 ClassDef *fcd=nullptr;
4352 QCString baseName=name();
4353 int i=baseName.find('<');
4354 if (i!=-1) baseName=baseName.left(i);
4355 return (isFriendClass() &&
4356 (fcd=getClass(baseName)) && fcd->isLinkable());
4357}
4358
4360{
4361 return m_defArgList.isDeleted();
4362}
4363
4365{
4367 (m_mtype==MemberType::Enumeration && m_docEnumValues) || // has enum values
4368 (m_defArgList.hasDocumentation()|| m_tArgList.hasTemplateDocumentation()); // has doc (template) arguments
4369}
4370
4371
4376
4378{
4379 QCString result;
4380 if (isStrong()) result=name();
4381 else if (getClassDef()) result=getClassDef()->displayName();
4382 else if (getNamespaceDef()) result=getNamespaceDef()->displayName();
4383 return result;
4384}
4385
4387{
4388 QCString memAnchor = name();
4389 if (!m_args.isEmpty()) memAnchor+=m_args;
4390 if (m_memSpec.isAlias()) // this is for backward compatibility
4391 {
4392 memAnchor.prepend(" = "+m_initializer);
4393 }
4394 memAnchor.prepend(definition()); // actually the method name is now included
4395 // twice, which is silly, but we keep it this way for backward
4396 // compatibility.
4397
4398
4399 // include number of template arguments as well,
4400 // to distinguish between two template
4401 // specializations that only differ in the template parameters.
4402 if (m_tArgList.hasParameters())
4403 {
4404 char buf[20];
4405 qsnprintf(buf,20,"%d:",static_cast<int>(m_tArgList.size()));
4406 buf[19]='\0';
4407 memAnchor.prepend(buf);
4408 }
4409 if (!m_requiresClause.isEmpty())
4410 {
4411 memAnchor+=" "+m_requiresClause;
4412 }
4413 if (m_redefineCount>0)
4414 {
4415 char buf[20];
4416 qsnprintf(buf,20,":%d",m_redefineCount);
4417 buf[19]='\0';
4418 memAnchor.append(buf);
4419 }
4420
4421 // convert to md5 hash
4422 uint8_t md5_sig[16];
4423 char sigStr[33];
4424 MD5Buffer(memAnchor.data(),static_cast<unsigned int>(memAnchor.length()),md5_sig);
4425 MD5SigToString(md5_sig,sigStr);
4426 m_anc = QCString("a")+sigStr;
4427}
4428
4430 const QCString &fileName,int startLine,
4431 bool hasDocs,MemberDef *member)
4432{
4433 //printf("%s MemberDefImpl::setGroupDef(%s)\n",qPrint(name()),qPrint(gd->name()));
4434 m_group=gd;
4435 m_grouppri=pri;
4436 m_groupFileName=fileName;
4437 m_groupStartLine=startLine;
4438 m_groupHasDocs=hasDocs;
4439 m_groupMember=member;
4441}
4442
4457
4465
4467{
4468 m_nspace=nd;
4469 setOuterScope(nd);
4470}
4471
4473 const ArgumentList &formalArgs,const std::unique_ptr<ArgumentList> &actualArgs) const
4474{
4475 //printf(" Member %s %s %s\n",qPrint(typeString()),qPrint(name()),qPrint(argsString()));
4476 std::unique_ptr<ArgumentList> actualArgList = std::make_unique<ArgumentList>(m_defArgList);
4477 if (!m_defArgList.empty())
4478 {
4479 // replace formal arguments with actuals
4480 for (Argument &arg : *actualArgList)
4481 {
4482 arg.type = substituteTemplateArgumentsInString(arg.type,formalArgs,actualArgs.get());
4483 }
4484 actualArgList->setTrailingReturnType(
4485 substituteTemplateArgumentsInString(actualArgList->trailingReturnType(),formalArgs,actualArgs.get()));
4486 }
4487
4488 QCString methodName=name();
4489 if (methodName.startsWith("operator ")) // conversion operator
4490 {
4491 methodName=substituteTemplateArgumentsInString(methodName,formalArgs,actualArgs.get());
4492 }
4493
4494 auto imd = createMemberDef(
4496 substituteTemplateArgumentsInString(m_type,formalArgs,actualArgs.get()),
4497 methodName,
4498 substituteTemplateArgumentsInString(m_args,formalArgs,actualArgs.get()),
4501 ArgumentList(), ArgumentList(), ""
4502 );
4503 auto mmd = toMemberDefMutable(imd.get());
4504 mmd->moveArgumentList(std::move(actualArgList));
4505 mmd->setDefinition(substituteTemplateArgumentsInString(m_def,formalArgs,actualArgs.get()));
4506 mmd->setBodyDef(getBodyDef());
4507 mmd->setBodySegment(getDefLine(),getStartBodyLine(),getEndBodyLine());
4508 mmd->setFormalTemplateArguments(formalArgs);
4509
4510 // TODO: init other member variables (if needed).
4511 // TODO: reimplemented info
4512 return imd;
4513}
4514
4516{
4517 //printf("%s: init=%s, initLines=%d maxInitLines=%d userInitLines=%d\n",
4518 // qPrint(name()),qPrint(m_initializer),m_initLines,
4519 // m_maxInitLines,m_userInitLines);
4520 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4521 return !m_initializer.isEmpty() && m_initLines==0 && // one line initializer
4522 !isFuncLikeMacro &&
4523 ((m_maxInitLines>0 && m_userInitLines==-1) || m_userInitLines>0); // enabled by default or explicitly
4524}
4525
4527{
4528 //printf("initLines=%d userInitLines=%d maxInitLines=%d\n",
4529 // initLines,userInitLines,maxInitLines);
4530 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4531 return (m_initLines>0 || (!m_initializer.isEmpty() && isFuncLikeMacro)) &&
4532 ((m_initLines<m_maxInitLines && m_userInitLines==-1) // implicitly enabled
4533 || m_initLines<m_userInitLines // explicitly enabled
4534 );
4535}
4536
4538{
4539 size_t indent=0;
4541 int l=static_cast<int>(m_initializer.length());
4542 int p=l-1;
4543 while (p>=0 && isspace(static_cast<uint8_t>(m_initializer.at(p)))) p--;
4544 m_initializer=m_initializer.left(p+1);
4545 m_initLines=m_initializer.contains('\n');
4546 //printf("%s::setInitializer(%s)\n",qPrint(name()),qPrint(m_initializer));
4547}
4548
4550{
4551 bool optimizeOutputForC = Config_getBool(OPTIMIZE_OUTPUT_FOR_C);
4552 SrcLangExt lang = getLanguage();
4553 if (!isLinkableInProject()) return;
4554 QCString memLabel;
4555 if (optimizeOutputForC)
4556 {
4557 memLabel=theTranslator->trGlobal(TRUE,TRUE);
4558 }
4559 else if (lang==SrcLangExt::Fortran)
4560 {
4561 memLabel=theTranslator->trSubprogram(TRUE,TRUE);
4562 }
4563 else
4564 {
4565 memLabel=theTranslator->trMember(TRUE,TRUE);
4566 }
4567 QCString memName = name();
4570 (toClassDef(pd))->displayName() : pd->name();
4572 QCString memArgs;
4573 if (!isRelated())
4574 {
4575 if (isObjCMethod())
4576 {
4577 memName = "[" + pd->name() + " " + name() + "]";
4578 }
4579 else
4580 {
4581 if (pd!=Doxygen::globalScope) memName.prepend(pdName+sep);
4582 memArgs = argsString();
4583 }
4584 }
4585 const RefItemVector &xrefItems = xrefListItems();
4586 if (sep!="::")
4587 {
4588 memName = substitute(memName,"::",sep);
4589 }
4590 addRefItem(xrefItems,
4591 qualifiedName()+argsString(), // argsString is needed for overloaded functions (see bug 609624)
4592 memLabel,
4593 getOutputFileBase()+"#"+anchor(),memName,memArgs,pd);
4594}
4595
4597{
4598 auto it = m_sectionMap.find(container);
4599 return it!=m_sectionMap.end() ? it->second : nullptr;
4600}
4601
4603{
4604 //printf("MemberDefImpl::setSectionList(%s,%p) name=%s\n",qPrint(d->name()),sl,qPrint(name()));
4605 m_sectionMap.emplace(container,sl);
4606}
4607
4609{
4610 if (count>25)
4611 {
4613 "Internal inconsistency: recursion detected in overload relation for member {}!",name());
4614 return Specifier::Normal;
4615 }
4616 Specifier v = m_virt;
4617 const MemberDef *rmd = reimplements();
4618 while (rmd && v==Specifier::Normal)
4619 {
4620 v = rmd->virtualness(count+1)==Specifier::Normal ? Specifier::Normal : Specifier::Virtual;
4621 rmd = rmd->reimplements();
4622 }
4623 return v;
4624}
4625
4626void MemberDefImpl::writeTagFile(TextStream &tagFile,bool useQualifiedName,bool showNamespaceMembers) const
4627{
4628 if (!isLinkableInProject()) return;
4629 if (!showNamespaceMembers && getNamespaceDef()) return;
4630 tagFile << " <member kind=\"";
4631 switch (m_mtype)
4632 {
4633 case MemberType::Define: tagFile << "define"; break;
4634 case MemberType::EnumValue: tagFile << "enumvalue"; break;
4635 case MemberType::Property: tagFile << "property"; break;
4636 case MemberType::Event: tagFile << "event"; break;
4637 case MemberType::Variable: tagFile << "variable"; break;
4638 case MemberType::Typedef: tagFile << "typedef"; break;
4639 case MemberType::Enumeration: tagFile << "enumeration"; break;
4640 case MemberType::Function: tagFile << "function"; break;
4641 case MemberType::Signal: tagFile << "signal"; break;
4642 case MemberType::Friend: tagFile << "friend"; break;
4643 case MemberType::DCOP: tagFile << "dcop"; break;
4644 case MemberType::Slot: tagFile << "slot"; break;
4645 case MemberType::Interface: tagFile << "interface"; break;
4646 case MemberType::Service: tagFile << "service"; break;
4647 case MemberType::Sequence: tagFile << "sequence"; break;
4648 case MemberType::Dictionary: tagFile << "dictionary"; break;
4649 }
4650 if (m_prot!=Protection::Public)
4651 {
4652 tagFile << "\" protection=\"";
4653 if (m_prot==Protection::Protected) tagFile << "protected";
4654 else if (m_prot==Protection::Package) tagFile << "package";
4655 else /* Private */ tagFile << "private";
4656 }
4657 if (m_virt!=Specifier::Normal)
4658 {
4659 tagFile << "\" virtualness=\"";
4660 if (m_virt==Specifier::Virtual) tagFile << "virtual";
4661 else /* Pure */ tagFile << "pure";
4662 }
4663 if (isStatic())
4664 {
4665 tagFile << "\" static=\"yes";
4666 }
4667 tagFile << "\">\n";
4668 if (typeString()!=QCString("@"))
4669 {
4670 tagFile << " <type>" << convertToXML(typeString()) << "</type>\n";
4671 }
4674 tagFile << " <name>" << convertToXML(useQualifiedName ? qualifiedName() : name()) << "</name>\n";
4675 tagFile << " <anchorfile>" << convertToXML(fn) << "</anchorfile>\n";
4676 tagFile << " <anchor>" << convertToXML(anchor()) << "</anchor>\n";
4677 QCString idStr = id();
4678 if (!idStr.isEmpty())
4679 {
4680 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
4681 }
4682 tagFile << " <arglist>" << convertToXML(argsString()) << "</arglist>\n";
4683 if (isStrong())
4684 {
4685 for (const auto &fmd : m_enumFields)
4686 {
4687 if (!fmd->isReference())
4688 {
4689 tagFile << " <enumvalue file=\"" << convertToXML(fn);
4690 tagFile << "\" anchor=\"" << convertToXML(fmd->anchor());
4691 idStr = fmd->id();
4692 if (!idStr.isEmpty())
4693 {
4694 tagFile << "\" clangid=\"" << convertToXML(idStr);
4695 }
4696 tagFile << "\">" << convertToXML(fmd->name()) << "</enumvalue>\n";
4697 }
4698 }
4699 }
4700 writeDocAnchorsToTagFile(tagFile);
4701 tagFile << " </member>\n";
4702}
4703
4705{
4706 m_isConstructorCached=1; // FALSE
4707 if (getClassDef())
4708 {
4709 if (m_isDMember) // for D
4710 {
4711 m_isConstructorCached = name()=="this" ? 2 : 1;
4712 return;
4713 }
4714 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4715 {
4716 m_isConstructorCached = name()=="__construct" ? 2 : 1;
4717 return;
4718 }
4719 else if (name()=="__init__" &&
4720 getLanguage()==SrcLangExt::Python) // for Python
4721 {
4722 m_isConstructorCached = 2; // TRUE
4723 return;
4724 }
4725 else // for other languages
4726 {
4727 QCString locName = getClassDef()->localName();
4728 int i=locName.find('<');
4729 if (i==-1) // not a template class
4730 {
4731 m_isConstructorCached = name()==locName ? 2 : 1;
4732 }
4733 else
4734 {
4735 m_isConstructorCached = name()==locName.left(i) ? 2 : 1;
4736 }
4737 return;
4738 }
4739 }
4740}
4741
4743{
4744 if (m_isConstructorCached==0)
4745 {
4746 MemberDefImpl *that = const_cast<MemberDefImpl*>(this);
4747 that->_computeIsConstructor();
4748 }
4750 return m_isConstructorCached==2;
4751
4752}
4753
4755{
4756 bool isDestructor = false;
4757 if (m_isDMember) // for D
4758 {
4759 isDestructor = name()=="~this";
4760 }
4761 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4762 {
4763 isDestructor = name()=="__destruct";
4764 }
4765 else if (name()=="__del__" &&
4766 getLanguage()==SrcLangExt::Python) // for Python
4767 {
4768 isDestructor = true;
4769 }
4770 else if (getLanguage()==SrcLangExt::Fortran) // for Fortran
4771 {
4772 isDestructor = typeString()=="final";
4773 }
4774 else // other languages
4775 {
4776 isDestructor =
4777 (name().find('~')!=-1 || name().find('!')!=-1) // The ! is for C++/CLI
4778 && name().find("operator")==-1;
4779 }
4781}
4782
4784{
4785 if (m_isDestructorCached==0)
4786 {
4787 MemberDefImpl *that=const_cast<MemberDefImpl*>(this);
4788 that->_computeIsDestructor();
4789 }
4791 return m_isDestructorCached==2;
4792}
4793
4795 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const
4796{
4797 int enumMemCount=0;
4798
4799 uint32_t numVisibleEnumValues=0;
4800 for (const auto &fmd : m_enumFields)
4801 {
4802 if (fmd->isBriefSectionVisible()) numVisibleEnumValues++;
4803 }
4804 if (numVisibleEnumValues==0 && !isBriefSectionVisible())
4805 {
4806 return;
4807 }
4808
4809 QCString n = name();
4810 int i=n.findRev("::");
4811 if (i!=-1) n=n.right(n.length()-i-2); // strip scope (TODO: is this needed?)
4812 if (n[0]!='@') // not an anonymous enum
4813 {
4815 {
4816 //_writeTagData(compoundType);
4817 writeLink(typeDecl,cd,nd,fd,gd,mod);
4818 }
4819 else
4820 {
4821 typeDecl.startBold();
4822 typeDecl.docify(n);
4823 typeDecl.endBold();
4824 }
4825 typeDecl.writeChar(' ');
4826 }
4827 if (!m_enumBaseType.isEmpty())
4828 {
4829 typeDecl.writeChar(':');
4830 typeDecl.writeChar(' ');
4831 typeDecl.docify(m_enumBaseType);
4832 typeDecl.writeChar(' ');
4833 }
4834
4835 uint32_t enumValuesPerLine = static_cast<uint32_t>(Config_getInt(ENUM_VALUES_PER_LINE));
4836 if (numVisibleEnumValues>0 && enumValuesPerLine>0)
4837 {
4838 typeDecl.docify("{ ");
4839
4840 auto it = m_enumFields.begin();
4841 if (it!=m_enumFields.end())
4842 {
4843 const MemberDef *fmd=*it;
4844 bool fmdVisible = fmd->isBriefSectionVisible();
4845 bool first=true;
4846 while (fmd)
4847 {
4848 if (fmdVisible)
4849 {
4850 if (!first)
4851 {
4852 typeDecl.writeString(", ");
4853 }
4854 /* in html we start a new line after a number of items */
4855 if (numVisibleEnumValues>enumValuesPerLine
4856 && (enumMemCount%enumValuesPerLine)==0
4857 )
4858 {
4859 typeDecl.pushGeneratorState();
4861 typeDecl.enable(OutputType::Latex);
4862 typeDecl.enable(OutputType::Docbook);
4863 typeDecl.lineBreak();
4864 typeDecl.disable(OutputType::Latex);
4865 typeDecl.disable(OutputType::Docbook);
4866 typeDecl.writeString("&#160;&#160;");
4867 typeDecl.popGeneratorState();
4868 }
4869
4870 if (fmd->hasDocumentation()) // enum value has docs
4871 {
4872 fmd->writeLink(typeDecl,cd,nd,fd,gd,mod);
4873 }
4874 else // no docs for this enum value
4875 {
4876 typeDecl.startBold();
4877 typeDecl.docify(fmd->name());
4878 typeDecl.endBold();
4879 }
4880 if (fmd->hasOneLineInitializer()) // enum value has initializer
4881 {
4882 //typeDecl.writeString(" = ");
4883 typeDecl.writeString(" ");
4884 typeDecl.parseText(fmd->initializer());
4885 }
4886 first=false;
4887 }
4888
4889 bool prevVisible = fmdVisible;
4890 ++it;
4891 if (it!=m_enumFields.end())
4892 {
4893 fmd=*it;
4894 }
4895 else
4896 {
4897 fmd=nullptr;
4898 }
4899 if (prevVisible)
4900 {
4901 typeDecl.disable(OutputType::Man);
4902 typeDecl.writeString("\n"); // to prevent too long lines in LaTeX
4903 typeDecl.enable(OutputType::Man);
4904 enumMemCount++;
4905 }
4906 }
4907 if (numVisibleEnumValues>enumValuesPerLine)
4908 {
4909 typeDecl.pushGeneratorState();
4911 typeDecl.lineBreak();
4912 typeDecl.popGeneratorState();
4913 }
4914 }
4915 typeDecl.docify(" }");
4916 }
4917}
4918
4919void MemberDefImpl::moveArgumentList(std::unique_ptr<ArgumentList> al)
4920{
4921 m_defArgList = *al;
4922}
4923
4924void MemberDefImpl::moveDeclArgumentList(std::unique_ptr<ArgumentList> al)
4925{
4926 m_declArgList = *al;
4927}
4928
4933
4935{
4936 m_type = t;
4937}
4938
4940{
4941 m_accessorClass = cd;
4942 m_accessorType = t;
4943}
4944
4949
4956
4962
4968
4974
4980
4985
4990
4992{
4993 if (getClassDef() && getClassDef()->isObjectiveC() && isFunction()) return TRUE;
4994 return FALSE;
4995}
4996
4998{
4999 if (getClassDef() && getClassDef()->isObjectiveC() && isProperty()) return TRUE;
5000 return FALSE;
5001}
5002
5004{
5005 if (getClassDef() && getClassDef()->isCSharp() && isProperty()) return TRUE;
5006 return FALSE;
5007}
5008
5010{
5011 if (isObjCMethod())
5012 {
5013 QCString qm;
5014 if (isStatic()) qm="+"; else qm="-";
5015 qm+="[";
5016 qm+=getClassDef()->name()+" ";
5017 qm+=name();
5018 qm+="]";
5019 return qm;
5020 }
5021 else if (m_enumScope && m_enumScope->isStrong())
5022 {
5023 return m_enumScope->qualifiedName()+
5025 localName();
5026 }
5027 else
5028 {
5030 }
5031}
5032
5034{
5035 if (ti)
5036 {
5037 //printf("%s: Setting tag name=%s anchor=%s\n",qPrint(name()),qPrint(ti->tagName),qPrint(ti->anchor));
5038 m_anc=ti->anchor;
5039 setReference(ti->tagName);
5041 }
5042}
5043
5044QCString MemberDefImpl::objCMethodName(bool localLink,bool showStatic) const
5045{
5046 QCString qm;
5047 if (showStatic)
5048 {
5049 if (isStatic()) qm="+ "; else qm="- ";
5050 }
5051 qm+=name();
5052 if (!localLink) // link to method of same class
5053 {
5054 qm+=" (";
5055 qm+=getClassDef()->name();
5056 qm+=")";
5057 }
5058 return qm;
5059}
5060
5062{
5063 return m_decl;
5064}
5065
5067{
5068 return m_def;
5069}
5070
5075
5077{
5078 return m_type;
5079}
5080
5082{
5083 return m_args;
5084}
5085
5087{
5088 return m_exception;
5089}
5090
5092{
5093 return m_bitfields;
5094}
5095
5097{
5098 return m_initializer;
5099}
5100
5102{
5103 return m_initLines;
5104}
5105
5110
5115
5117{
5118 return m_classDef;
5119}
5120
5125
5130
5132{
5133 return m_fileDef;
5134}
5135
5137{
5138 return m_fileDef;
5139}
5140
5142{
5143 return m_nspace;
5144}
5145
5150
5152{
5153 return m_read;
5154}
5155
5157{
5158 return m_write;
5159}
5160
5162{
5163 return m_group;
5164}
5165
5167{
5168 return m_group;
5169}
5170
5172{
5173 return m_moduleDef;
5174}
5175
5180
5185
5187{
5188 return m_groupStartLine;
5189}
5190
5192{
5193 return m_groupHasDocs;
5194}
5195
5197{
5198 return m_prot;
5199}
5200
5202{
5203 return m_mtype;
5204}
5205
5207{
5209}
5210
5212{
5213 return m_mtype==MemberType::Slot;
5214}
5215
5217{
5219}
5220
5222{
5224}
5225
5227{
5229}
5230
5232{
5234}
5235
5237{
5239}
5240
5242{
5244}
5245
5247{
5249}
5250
5252{
5253 return m_mtype==MemberType::Variable && QCString(argsString()).find(")(")!=-1;
5254}
5255
5257{
5259}
5260
5262{
5264}
5265
5267{
5268 return m_mtype==MemberType::DCOP;
5269}
5270
5272{
5274}
5275
5277{
5278 return m_mtype==MemberType::Event;
5279}
5280
5282{
5283 return m_related == Relationship::Related;
5284}
5285
5287{
5288 return m_related == Relationship::Foreign;
5289}
5290
5292{
5293 return m_stat;
5294}
5295
5297{
5298 return m_memSpec.isInline();
5299}
5300
5302{
5303 return m_memSpec.isExplicit();
5304}
5305
5307{
5308 return m_memSpec.isMutable();
5309}
5310
5312{
5313 return m_memSpec.isThreadLocal();
5314}
5315
5317{
5318 return m_memSpec.isGettable();
5319}
5320
5322{
5323 return m_memSpec.isPrivateGettable();
5324}
5325
5327{
5328 return m_memSpec.isProtectedGettable();
5329}
5330
5332{
5333 return m_memSpec.isSettable();
5334}
5335
5337{
5338 return m_memSpec.isPrivateSettable();
5339}
5340
5342{
5343 return m_memSpec.isProtectedSettable();
5344}
5345
5347{
5348 return m_memSpec.isAddable();
5349}
5350
5352{
5353 return m_memSpec.isRemovable();
5354}
5355
5357{
5358 return m_memSpec.isRaisable();
5359}
5360
5362{
5363 return m_memSpec.isReadable();
5364}
5365
5367{
5368 return m_memSpec.isWritable();
5369}
5370
5372{
5373 return m_memSpec.isFinal();
5374}
5375
5377{
5378 return m_memSpec.isNew();
5379}
5380
5382{
5383 return m_memSpec.isSealed();
5384}
5385
5387{
5388 return m_memSpec.isOverride();
5389}
5390
5392{
5393 return m_memSpec.isInitonly();
5394}
5395
5397{
5398 return m_memSpec.isAbstract();
5399}
5400
5402{
5403 return m_memSpec.isOptional();
5404}
5405
5407{
5408 return m_memSpec.isRequired();
5409}
5410
5412{
5413 return m_memSpec.isNonAtomic();
5414}
5415
5417{
5418 return m_memSpec.isCopy();
5419}
5420
5422{
5423 return m_memSpec.isAssign();
5424}
5425
5427{
5428 return m_memSpec.isRetain();
5429}
5430
5432{
5433 return m_memSpec.isWeak();
5434}
5435
5437{
5438 return m_memSpec.isStrong();
5439}
5440
5442{
5443 return m_memSpec.isEnumStruct();
5444}
5445
5447{
5449 m_enumScope &&
5450 m_enumScope->isStrong();
5451}
5452
5454{
5455 return m_memSpec.isUnretained();
5456}
5457
5459{
5460 return m_memSpec.isAlias();
5461}
5462
5464{
5465 return m_memSpec.isDefault();
5466}
5467
5469{
5470 return m_memSpec.isDelete();
5471}
5472
5474{
5475 return m_memSpec.isNoExcept();
5476}
5477
5479{
5480 return m_memSpec.isAttribute();
5481}
5482
5484{
5485 return m_memSpec.isProperty();
5486}
5487
5489{
5490 return m_memSpec.isReadonly();
5491}
5492
5494{
5495 return m_memSpec.isBound();
5496}
5497
5499{
5500 return m_memSpec.isConstrained();
5501}
5502
5504{
5505 return m_memSpec.isTransient();
5506}
5507
5509{
5510 return m_memSpec.isMaybeVoid();
5511}
5512
5514{
5515 return m_memSpec.isMaybeDefault();
5516}
5517
5519{
5520 return m_memSpec.isMaybeAmbiguous();
5521}
5522
5524{
5525 return m_memSpec.isPublished();
5526}
5527
5528
5530{
5531 return m_implOnly;
5532}
5533
5535{
5536 return m_explExt;
5537}
5538
5540{
5541 return m_tspec;
5542}
5543
5545{
5546 return isFunction() ||
5547 isSlot() ||
5548 isSignal() ||
5549 isConstructor() ||
5550 isDestructor() ||
5551 isObjCMethod() ||
5552 isFriend();
5553}
5554
5556{
5557 return m_relatedAlso;
5558}
5559
5561{
5562 return m_docEnumValues;
5563}
5564
5566{
5567 return m_annEnumType;
5568}
5569
5571{
5572 return m_docsForDefinition;
5573}
5574
5576{
5577 return m_enumScope;
5578}
5579
5581{
5582 return m_livesInsideEnum;
5583}
5584
5586{
5587 return m_memSpec.isLocal();
5588}
5589
5591{
5592 return m_memSpec.isNoDiscard();
5593}
5594
5596{
5597 return m_memSpec.isConstExpr();
5598}
5599
5601{
5602 return m_memSpec.isConstEval();
5603}
5604
5606{
5607 return m_memSpec.isConstInit();
5608}
5609
5611{
5612 return m_enumFields;
5613}
5614
5616{
5617 return m_examples;
5618}
5619
5621{
5622 return m_proto;
5623}
5624
5626{
5627 return m_defArgList;
5628}
5629
5631{
5632 return m_declArgList;
5633}
5634
5636{
5637 ArgumentList &decAl = m_declArgList;
5638 ArgumentList &defAl = m_defArgList;
5639 const ArgumentList &decAlSrc = md->declArgumentList();
5640 const ArgumentList &defAlSrc = md->argumentList();
5641 auto decSrc = decAlSrc.begin(), defSrc = defAlSrc.begin();
5642 for (auto decIt = decAl.begin(), defIt = defAl.begin();
5643 decIt != decAl.end() && defIt != defAl.end() && decSrc != decAlSrc.end() && defSrc != defAlSrc.end();
5644 ++decIt, ++defIt, ++decSrc, ++defSrc++)
5645 {
5646 Argument &decA = *decIt;
5647 Argument &defA = *defIt;
5648 const Argument &decAS = *decSrc;
5649 const Argument &defAS = *defSrc;
5650 if (decA.name.isEmpty())
5651 {
5652 if (!defA.name.isEmpty())
5653 {
5654 decA.name = defA.name;
5655 }
5656 else if (!decAS.name.isEmpty())
5657 {
5658 decA.name = decAS.name;
5659 }
5660 else if (!defAS.name.isEmpty())
5661 {
5662 decA.name = defAS.name;
5663 }
5664 }
5665 if (defA.name.isEmpty())
5666 {
5667 if (!decA.name.isEmpty())
5668 {
5669 defA.name = decA.name;
5670 }
5671 else if (!decAS.name.isEmpty())
5672 {
5673 defA.name = decAS.name;
5674 }
5675 else if (!defAS.name.isEmpty())
5676 {
5677 defA.name = defAS.name;
5678 }
5679 }
5680 }
5681}
5682
5684{
5685 return m_tArgList;
5686}
5687
5692
5694{
5695 return m_grpId;
5696}
5697
5702
5704{
5705 return m_annScope;
5706}
5707
5709{
5710 return m_hasCallGraph;
5711}
5712
5714{
5715 bool enabled = m_hasCallGraph &&
5716 (isFunction() || isSlot() || isSignal()) &&
5717 Config_getBool(HAVE_DOT);
5718 if (enabled)
5719 {
5720 bool trivial = DotCallGraph::isTrivial(this,FALSE);
5721 return !trivial;
5722 }
5723 return FALSE;
5724}
5725
5727{
5728 return m_hasCallerGraph;
5729}
5730
5732{
5733 bool enabled = m_hasCallerGraph &&
5734 (isFunction() || isSlot() || isSignal()) &&
5735 Config_getBool(HAVE_DOT);
5736 if (enabled)
5737 {
5738 bool trivial = DotCallGraph::isTrivial(this,TRUE);
5739 return !trivial;
5740 }
5741 return FALSE;
5742}
5743
5748
5753
5755{
5756 return m_hasInlineSource;
5757}
5758
5760{
5761 return m_hasEnumValues;
5762}
5763
5765{
5766 return m_templateMaster;
5767}
5768
5769std::optional<ArgumentList> MemberDefImpl::formalTemplateArguments() const
5770{
5772}
5773
5775{
5776 return m_isTypedefValCached;
5777}
5778
5783
5788
5790{
5791 //printf("MemberDefImpl::getCachedResolvedTypedef()=%s\n",qPrint(m_cachedResolvedType));
5792 return m_cachedResolvedType;
5793}
5794
5796{
5797 return m_memDef;
5798}
5799
5801{
5802 return m_memDec;
5803}
5804
5806{
5807 return m_docProvider;
5808}
5809
5811{
5812 return m_groupAlias;
5813}
5814
5819
5821{
5822 return m_declLine;
5823}
5824
5826{
5827 return m_declColumn;
5828}
5829
5830
5831//----------------------------------------------
5832
5838
5840{
5841 m_def=d;
5842}
5843
5851
5853{
5854 m_moduleDef=mod;
5855}
5856
5862
5867
5872
5877
5882
5884{
5885 for (const auto &sx : qualifiers)
5886 {
5887 bool alreadyAdded = std::find(m_qualifiers.begin(), m_qualifiers.end(), sx) != m_qualifiers.end();
5888 if (!alreadyAdded)
5889 {
5890 m_qualifiers.push_back(sx);
5891 }
5892 }
5893}
5894
5899
5901{
5902 if (lines!=-1)
5903 {
5904 m_userInitLines=lines;
5905 }
5906}
5907
5909{
5910 m_read=r;
5911}
5912
5914{
5915 m_write=w;
5916}
5917
5919{
5920 m_tspec=b;
5921}
5922
5924{
5925 m_related = Relationship::Related;
5927}
5928
5930{
5931 m_related = Relationship::Foreign;
5933}
5934
5936{
5937 m_docProvider = md;
5938}
5939
5941{
5942 m_args = as;
5943}
5944
5949
5956
5958{
5959 m_docEnumValues=value;
5960}
5961
5963{
5964 m_annEnumType = md;
5965}
5966
5967void MemberDefImpl::setPrototype(bool p,const QCString &df,int line,int column)
5968{
5969 m_proto=p;
5970 if (p)
5971 {
5972 setDeclFile(df,line,column);
5973 }
5974 else
5975 {
5976 setDefFile(df,line,column);
5977 }
5978}
5979
5980void MemberDefImpl::setExplicitExternal(bool b,const QCString &df,int line,int column)
5981{
5982 m_explExt=b;
5983 if (b)
5984 {
5985 setDeclFile(df,line,column);
5986 }
5987 else
5988 {
5989 setDefFile(df,line,column);
5990 }
5991}
5992
5993void MemberDefImpl::setDeclFile(const QCString &df,int line,int column)
5994{
5995 m_declFileName = df;
5996 m_declLine = line;
5997 m_declColumn = column;
5998}
5999
6001{
6002 m_grpId=id;
6003}
6004
6009
6011{
6012 m_annScope=b;
6013}
6014
6019
6024
6030
6035
6040
6042{
6043 m_groupAlias = md;
6044}
6045
6050
6055
6060
6062{
6063 return m_category;
6064}
6065
6067{
6068 m_category = def;
6069}
6070
6072{
6073 return m_categoryRelation;
6074}
6075
6080
6082{
6083 m_enumBaseType = type;
6084}
6085
6087{
6088 return m_enumBaseType;
6089}
6090
6092{
6093 m_requiresClause = req;
6094}
6095
6100
6101void MemberDefImpl::cacheTypedefVal(const ClassDef*val, const QCString & templSpec, const QCString &resolvedType)
6102{
6105 m_cachedTypedefTemplSpec=templSpec;
6106 m_cachedResolvedType=resolvedType;
6107 //printf("MemberDefImpl::cacheTypedefVal=%s m_impl=%p\n",qPrint(m_cachedResolvedType),m_impl);
6108}
6109
6111{
6112 {
6113 const ArgumentList &srcAl = bmd->argumentList();
6114 ArgumentList &dstAl = m_defArgList;
6115 auto srcIt = srcAl.begin();
6116 auto dstIt = dstAl.begin();
6117 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6118 {
6119 Argument &argDst = *dstIt;
6120 const Argument &argSrc = *srcIt;
6121 argDst.name = argSrc.name;
6122 argDst.docs = argSrc.docs;
6123 ++srcIt;
6124 ++dstIt;
6125 }
6126 }
6127
6128 {
6129 const ArgumentList &srcAl = bmd->declArgumentList();
6130 ArgumentList &dstAl = m_declArgList;
6131 auto srcIt = srcAl.begin();
6132 auto dstIt = dstAl.begin();
6133
6134 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6135 {
6136 Argument &argDst = *dstIt;
6137 const Argument &argSrc = *srcIt;
6138 argDst.name = argSrc.name;
6139 argDst.docs = argSrc.docs;
6140 ++srcIt;
6141 ++dstIt;
6142 }
6143 }
6144}
6145
6147{
6148 for (Argument &a : al)
6149 {
6150 a.canType.clear();
6151 }
6152}
6153
6159
6164
6166{
6167 return m_numberOfFlowKW;
6168}
6169
6170//----------------
6171
6173{
6174 return DefinitionMixin::name();
6175}
6176
6177//----------------
6178
6180{
6181 for (auto decIt = decAl.begin(), defIt = defAl.begin();
6182 decIt!= decAl.end() && defIt!= defAl.end();
6183 ++decIt, ++defIt)
6184 {
6185 Argument &decA = *decIt;
6186 Argument &defA = *defIt;
6187 if (decA.docs.isEmpty() && !defA.docs.isEmpty())
6188 {
6189 decA.docs = defA.docs;
6190 }
6191 else if (defA.docs.isEmpty() && !decA.docs.isEmpty())
6192 {
6193 defA.docs = decA.docs;
6194 }
6195 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6196 {
6197 if (decA.name.isEmpty() && !defA.name.isEmpty())
6198 {
6199 decA.name = defA.name;
6200 }
6201 else if (defA.name.isEmpty() && !decA.name.isEmpty())
6202 {
6203 defA.name = decA.name;
6204 }
6205 }
6206 }
6207}
6208
6210{
6211 AUTO_TRACE("mdec='{}' mdef='{}' mdec.isPrototype={} mdef.isPrototype={}",
6212 mdec->name(), mdef->name(), mdec->isPrototype(), mdef->isPrototype());
6213 if (
6214 (mdef->isFunction() && !mdef->isStatic() && !mdef->isPrototype()) ||
6215 (mdef->isVariable() && !mdef->isExternal() && !mdef->isStatic())
6216 )
6217 {
6218 bool sameNumTemplateArgs = mdef->templateArguments().size()==mdec->templateArguments().size();
6219
6220 ArgumentList &mdefAl = const_cast<ArgumentList&>(mdef->argumentList());
6221 ArgumentList &mdecAl = const_cast<ArgumentList&>(mdec->argumentList());
6222 if (sameNumTemplateArgs &&
6223 matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),&mdefAl,
6224 mdec->getOuterScope(),mdec->getFileDef(),&mdecAl,
6225 TRUE,mdef->getLanguage()
6226 )
6227 ) /* match found */
6228 {
6229 AUTO_TRACE_ADD("combining definition and declaration");
6230
6231 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6232 {
6233 mdec->resolveUnnamedParameters(mdef);
6234 }
6235
6236 // first merge argument documentation
6237 transferArgumentDocumentation(mdecAl,mdefAl);
6238
6239 /* copy documentation between function definition and declaration */
6240 if (!mdec->briefDescription().isEmpty())
6241 {
6242 mdef->setBriefDescription(mdec->briefDescription(),mdec->briefFile(),mdec->briefLine());
6243 }
6244 else if (!mdef->briefDescription().isEmpty())
6245 {
6246 mdec->setBriefDescription(mdef->briefDescription(),mdef->briefFile(),mdef->briefLine());
6247 }
6248 if (!mdef->documentation().isEmpty())
6249 {
6250 //printf("transferring docs mdef->mdec (%s->%s)\n",mdef->argsString(),mdec->argsString());
6251 mdec->setDocumentation(mdef->documentation(),mdef->docFile(),mdef->docLine());
6253 if (mdefAl.hasParameters())
6254 {
6255 auto mdefAlComb = stringToArgumentList(mdef->getLanguage(),mdef->argsString());
6256 transferArgumentDocumentation(mdefAl,*mdefAlComb);
6257 mdec->moveArgumentList(std::move(mdefAlComb));
6258 }
6259 }
6260 else if (!mdec->documentation().isEmpty())
6261 {
6262 //printf("transferring docs mdec->mdef (%s->%s)\n",mdec->argsString(),mdef->argsString());
6263 mdef->setDocumentation(mdec->documentation(),mdec->docFile(),mdec->docLine());
6265 if (mdecAl.hasParameters())
6266 {
6267 auto mdecAlComb = stringToArgumentList(mdec->getLanguage(),mdec->argsString());
6268 transferArgumentDocumentation(mdecAl,*mdecAlComb);
6269 mdef->moveDeclArgumentList(std::move(mdecAlComb));
6270 }
6271 }
6272 if (!mdef->inbodyDocumentation().isEmpty())
6273 {
6274 mdec->setInbodyDocumentation(mdef->inbodyDocumentation(),mdef->inbodyFile(),mdef->inbodyLine());
6275 }
6276 else if (!mdec->inbodyDocumentation().isEmpty())
6277 {
6278 mdef->setInbodyDocumentation(mdec->inbodyDocumentation(),mdec->inbodyFile(),mdec->inbodyLine());
6279 }
6280 if (mdec->getStartBodyLine()!=-1 && mdef->getStartBodyLine()==-1)
6281 {
6282 //printf("body mdec->mdef %d-%d\n",mdec->getStartBodyLine(),mdef->getEndBodyLine());
6283 mdef->setBodySegment(mdec->getDefLine(),mdec->getStartBodyLine(),mdec->getEndBodyLine());
6284 mdef->setBodyDef(mdec->getBodyDef());
6285 //mdef->setBodyMember(mdec);
6286 }
6287 else if (mdef->getStartBodyLine()!=-1 && mdec->getStartBodyLine()==-1)
6288 {
6289 //printf("body mdef->mdec %d-%d\n",mdef->getStartBodyLine(),mdec->getEndBodyLine());
6290 mdec->setBodySegment(mdef->getDefLine(),mdef->getStartBodyLine(),mdef->getEndBodyLine());
6291 mdec->setBodyDef(mdef->getBodyDef());
6292 //mdec->setBodyMember(mdef);
6293 }
6296
6297 // copy group info.
6298 if (mdec->getGroupDef()==nullptr && mdef->getGroupDef()!=nullptr)
6299 {
6300 mdec->setGroupDef(mdef->getGroupDef(),
6301 mdef->getGroupPri(),
6302 mdef->docFile(),
6303 mdef->docLine(),
6304 mdef->hasDocumentation(),
6305 mdef
6306 );
6307 }
6308 else if (mdef->getGroupDef()==nullptr && mdec->getGroupDef()!=nullptr)
6309 {
6310 mdef->setGroupDef(mdec->getGroupDef(),
6311 mdec->getGroupPri(),
6312 mdec->docFile(),
6313 mdec->docLine(),
6314 mdec->hasDocumentation(),
6315 mdec
6316 );
6317 }
6318
6319
6320 mdec->mergeRefItems(mdef);
6321 mdef->mergeRefItems(mdec);
6322
6323 mdef->setMemberDeclaration(mdec);
6324 mdec->setMemberDefinition(mdef);
6325
6326 mergeMemberOverrideOptions(mdec,mdef);
6327
6328 mdef->addQualifiers(mdec->getQualifiers());
6329 mdec->addQualifiers(mdef->getQualifiers());
6330 }
6331 }
6332}
6333
6335{
6336 if (m_templateMaster)
6337 {
6338 return m_templateMaster->briefDescription(abbr);
6339 }
6340 else
6341 {
6343 }
6344}
6345
6347{
6348 if (m_templateMaster)
6349 {
6350 return m_templateMaster->documentation();
6351 }
6352 else
6353 {
6355 }
6356}
6357
6359{
6360 if (m_templateMaster)
6361 {
6362 return m_templateMaster->hasUserDocumentation();
6363 }
6364 else
6365 {
6367 }
6368}
6369
6371{
6372 return m_typeConstraints;
6373}
6374
6376{
6377 bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
6378 bool isFriendToHide = hideFriendCompounds &&
6379 (m_type=="friend class" ||
6380 m_type=="friend struct" ||
6381 m_type=="friend union");
6382 return isFriendToHide;
6383}
6384
6386{
6387 return (isFriend() &&
6388 (m_type=="friend class" || m_type=="friend struct" ||
6389 m_type=="friend union"));
6390}
6391
6392
6394{
6395 return !(isFriend() && isFriendToHide());
6396}
6397
6399{
6400 return isFunction() || isSlot() || isSignal();
6401}
6402
6404{
6405 return isRelated() || isForeign() || (isFriend() && !isFriendToHide());
6406}
6407
6409{
6411 (m_templateMaster && m_templateMaster->isReference());
6412}
6413
6437
6439{
6440 return m_redefineCount;
6441}
6442
6444{
6445 m_redefineCount=count;
6446}
6447
6448//-------------------------------------------------------------------------------
6449// Helpers
6450
6452
6454{
6455 MemberDefMutable *src = toMemberDefMutable(const_cast<MemberDef*>(s));
6456 MemberDefMutable *dst = toMemberDefMutable(const_cast<MemberDef*>(d));
6457 if (src==nullptr || dst==nullptr) return;
6458 //printf("--> addDocCrossReference src=%s,dst=%s\n",qPrint(src->name()),qPrint(dst->name()));
6459 if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types
6460 if ((dst->hasReferencedByRelation() || dst->hasCallerGraph()) &&
6461 src->isCallable()
6462 )
6463 {
6464 QCString sourceRefName = src->sourceRefName();
6467
6468 // ---- critical section
6469 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6470 dst->addSourceReferencedBy(src,sourceRefName);
6471 if (mdDef)
6472 {
6473 mdDef->addSourceReferencedBy(src,sourceRefName);
6474 }
6475 if (mdDecl)
6476 {
6477 mdDecl->addSourceReferencedBy(src,sourceRefName);
6478 }
6479 // ---- end critical section
6480 }
6481 if ((src->hasReferencesRelation() || src->hasCallGraph()) &&
6482 src->isCallable()
6483 )
6484 {
6485 QCString sourceRefName = dst->sourceRefName();
6488
6489 // ---- critical section
6490 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6491 src->addSourceReferences(dst,sourceRefName);
6492 if (mdDef)
6493 {
6494 mdDef->addSourceReferences(dst,sourceRefName);
6495 }
6496 if (mdDecl)
6497 {
6498 mdDecl->addSourceReferences(dst,sourceRefName);
6499 }
6500 // ---- end critical section
6501 }
6502}
6503
6504// --- Cast functions
6505//
6507{
6508 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6509 {
6510 return static_cast<MemberDef*>(d);
6511 }
6512 else
6513 {
6514 return nullptr;
6515 }
6516}
6517
6519{
6520 Definition *d = toDefinition(md);
6521 if (d && typeid(*d)==typeid(MemberDefImpl))
6522 {
6523 return static_cast<MemberDef*>(d);
6524 }
6525 else
6526 {
6527 return nullptr;
6528 }
6529}
6530
6532{
6533 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6534 {
6535 return static_cast<const MemberDef*>(d);
6536 }
6537 else
6538 {
6539 return nullptr;
6540 }
6541}
6542
6544{
6545 if (d && typeid(*d)==typeid(MemberDefImpl))
6546 {
6547 return static_cast<MemberDefMutable*>(d);
6548 }
6549 else
6550 {
6551 return nullptr;
6552 }
6553}
6554
6555
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:151
#define Config_getInt(name)
Definition config.h:34
#define Config_getList(name)
Definition config.h:38
#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:822
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:8953
static void writeTagFile()
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1956
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:842
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:730
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:569
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5127
bool protectionLevelVisible(Protection prot)
Definition util.cpp:5869
QCString substituteTemplateArgumentsInString(const QCString &nm, const ArgumentList &formalArgs, const ArgumentList *actualArgs)
Definition util.cpp:4295
void writeTypeConstraints(OutputList &ol, const Definition *d, const ArgumentList &al)
Definition util.cpp:5375
QCString stripAnonymousNamespaceScope(const QCString &s)
Definition util.cpp:232
QCString stripFromIncludePath(const QCString &path)
Definition util.cpp:331
QCString tempArgListToString(const ArgumentList &al, SrcLangExt lang, bool includeDefault)
Definition util.cpp:1237
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:4746
void writePageRef(OutputList &ol, const QCString &cn, const QCString &mn)
Definition util.cpp:261
QCString removeAnonymousScopes(const QCString &str)
Definition util.cpp:163
bool matchArguments2(const Definition *srcScope, const FileDef *srcFileScope, const ArgumentList *srcAl, const Definition *dstScope, const FileDef *dstFileScope, const ArgumentList *dstAl, bool checkCV, SrcLangExt lang)
Definition util.cpp:1959
QCString inlineTemplateArgListToDoc(const ArgumentList &al)
Definition util.cpp:1165
QCString stripExtension(const QCString &fName)
Definition util.cpp:4865
QCString convertToXML(const QCString &s, bool keepEntities)
Definition util.cpp:3842
QCString detab(const QCString &s, size_t &refIndent)
Definition util.cpp:6650
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:5829
void mergeMemberOverrideOptions(MemberDefMutable *md1, MemberDefMutable *md2)
Definition util.cpp:6791
void writeMarkerList(OutputList &ol, const std::string &markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)
Definition util.cpp:1094
QCString inlineArgListToDoc(const ArgumentList &al)
Definition util.cpp:1147
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:895
void writeExamples(OutputList &ol, const ExampleList &list)
Definition util.cpp:1118
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:4843
A bunch of utility functions.
bool isId(int c)
Definition util.h:208