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 destructor
4328 )
4329 )
4330 {
4332 "return type of member {} is not documented",
4333 qualifiedName());
4334 }
4335 }
4336 if (Config_getBool(WARN_IF_DOC_ERROR) &&
4338 (isVoidReturn || // void return type
4339 isFortranSubroutine || // fortran subroutine
4340 isConstructor() || // a constructor
4341 isDestructor())) // or destructor
4342 {
4343 warn_doc_error(docFile(),docLine(),"found documented return type for {} that does not return anything",
4344 qualifiedName());
4345 }
4346}
4347
4349{
4350 ClassDef *fcd=nullptr;
4351 QCString baseName=name();
4352 int i=baseName.find('<');
4353 if (i!=-1) baseName=baseName.left(i);
4354 return (isFriendClass() &&
4355 (fcd=getClass(baseName)) && fcd->isLinkable());
4356}
4357
4359{
4360 return m_defArgList.isDeleted();
4361}
4362
4364{
4366 (m_mtype==MemberType::Enumeration && m_docEnumValues) || // has enum values
4367 (m_defArgList.hasDocumentation()|| m_tArgList.hasTemplateDocumentation()); // has doc (template) arguments
4368}
4369
4370
4375
4377{
4378 QCString result;
4379 if (isStrong()) result=name();
4380 else if (getClassDef()) result=getClassDef()->displayName();
4381 else if (getNamespaceDef()) result=getNamespaceDef()->displayName();
4382 return result;
4383}
4384
4386{
4387 QCString memAnchor = name();
4388 if (!m_args.isEmpty()) memAnchor+=m_args;
4389 if (m_memSpec.isAlias()) // this is for backward compatibility
4390 {
4391 memAnchor.prepend(" = "+m_initializer);
4392 }
4393 memAnchor.prepend(definition()); // actually the method name is now included
4394 // twice, which is silly, but we keep it this way for backward
4395 // compatibility.
4396
4397
4398 // include number of template arguments as well,
4399 // to distinguish between two template
4400 // specializations that only differ in the template parameters.
4401 if (m_tArgList.hasParameters())
4402 {
4403 char buf[20];
4404 qsnprintf(buf,20,"%d:",static_cast<int>(m_tArgList.size()));
4405 buf[19]='\0';
4406 memAnchor.prepend(buf);
4407 }
4408 if (!m_requiresClause.isEmpty())
4409 {
4410 memAnchor+=" "+m_requiresClause;
4411 }
4412 if (m_redefineCount>0)
4413 {
4414 char buf[20];
4415 qsnprintf(buf,20,":%d",m_redefineCount);
4416 buf[19]='\0';
4417 memAnchor.append(buf);
4418 }
4419
4420 // convert to md5 hash
4421 uint8_t md5_sig[16];
4422 char sigStr[33];
4423 MD5Buffer(memAnchor.data(),static_cast<unsigned int>(memAnchor.length()),md5_sig);
4424 MD5SigToString(md5_sig,sigStr);
4425 m_anc = QCString("a")+sigStr;
4426}
4427
4429 const QCString &fileName,int startLine,
4430 bool hasDocs,MemberDef *member)
4431{
4432 //printf("%s MemberDefImpl::setGroupDef(%s)\n",qPrint(name()),qPrint(gd->name()));
4433 m_group=gd;
4434 m_grouppri=pri;
4435 m_groupFileName=fileName;
4436 m_groupStartLine=startLine;
4437 m_groupHasDocs=hasDocs;
4438 m_groupMember=member;
4440}
4441
4456
4464
4466{
4467 m_nspace=nd;
4468 setOuterScope(nd);
4469}
4470
4472 const ArgumentList &formalArgs,const std::unique_ptr<ArgumentList> &actualArgs) const
4473{
4474 //printf(" Member %s %s %s\n",qPrint(typeString()),qPrint(name()),qPrint(argsString()));
4475 std::unique_ptr<ArgumentList> actualArgList = std::make_unique<ArgumentList>(m_defArgList);
4476 if (!m_defArgList.empty())
4477 {
4478 // replace formal arguments with actuals
4479 for (Argument &arg : *actualArgList)
4480 {
4481 arg.type = substituteTemplateArgumentsInString(arg.type,formalArgs,actualArgs.get());
4482 }
4483 actualArgList->setTrailingReturnType(
4484 substituteTemplateArgumentsInString(actualArgList->trailingReturnType(),formalArgs,actualArgs.get()));
4485 }
4486
4487 QCString methodName=name();
4488 if (methodName.startsWith("operator ")) // conversion operator
4489 {
4490 methodName=substituteTemplateArgumentsInString(methodName,formalArgs,actualArgs.get());
4491 }
4492
4493 auto imd = createMemberDef(
4495 substituteTemplateArgumentsInString(m_type,formalArgs,actualArgs.get()),
4496 methodName,
4497 substituteTemplateArgumentsInString(m_args,formalArgs,actualArgs.get()),
4500 ArgumentList(), ArgumentList(), ""
4501 );
4502 auto mmd = toMemberDefMutable(imd.get());
4503 mmd->moveArgumentList(std::move(actualArgList));
4504 mmd->setDefinition(substituteTemplateArgumentsInString(m_def,formalArgs,actualArgs.get()));
4505 mmd->setBodyDef(getBodyDef());
4506 mmd->setBodySegment(getDefLine(),getStartBodyLine(),getEndBodyLine());
4507 mmd->setFormalTemplateArguments(formalArgs);
4508
4509 // TODO: init other member variables (if needed).
4510 // TODO: reimplemented info
4511 return imd;
4512}
4513
4515{
4516 //printf("%s: init=%s, initLines=%d maxInitLines=%d userInitLines=%d\n",
4517 // qPrint(name()),qPrint(m_initializer),m_initLines,
4518 // m_maxInitLines,m_userInitLines);
4519 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4520 return !m_initializer.isEmpty() && m_initLines==0 && // one line initializer
4521 !isFuncLikeMacro &&
4522 ((m_maxInitLines>0 && m_userInitLines==-1) || m_userInitLines>0); // enabled by default or explicitly
4523}
4524
4526{
4527 //printf("initLines=%d userInitLines=%d maxInitLines=%d\n",
4528 // initLines,userInitLines,maxInitLines);
4529 bool isFuncLikeMacro = m_mtype==MemberType::Define && m_defArgList.hasParameters();
4530 return (m_initLines>0 || (!m_initializer.isEmpty() && isFuncLikeMacro)) &&
4531 ((m_initLines<m_maxInitLines && m_userInitLines==-1) // implicitly enabled
4532 || m_initLines<m_userInitLines // explicitly enabled
4533 );
4534}
4535
4537{
4539 int l=static_cast<int>(m_initializer.length());
4540 int p=l-1;
4541 while (p>=0 && isspace(static_cast<uint8_t>(m_initializer.at(p)))) p--;
4542 m_initializer=m_initializer.left(p+1);
4543 m_initLines=m_initializer.contains('\n');
4544 //printf("%s::setInitializer(%s)\n",qPrint(name()),qPrint(m_initializer));
4545}
4546
4548{
4549 bool optimizeOutputForC = Config_getBool(OPTIMIZE_OUTPUT_FOR_C);
4550 SrcLangExt lang = getLanguage();
4551 if (!isLinkableInProject()) return;
4552 QCString memLabel;
4553 if (optimizeOutputForC)
4554 {
4555 memLabel=theTranslator->trGlobal(TRUE,TRUE);
4556 }
4557 else if (lang==SrcLangExt::Fortran)
4558 {
4559 memLabel=theTranslator->trSubprogram(TRUE,TRUE);
4560 }
4561 else
4562 {
4563 memLabel=theTranslator->trMember(TRUE,TRUE);
4564 }
4565 QCString memName = name();
4568 (toClassDef(pd))->displayName() : pd->name();
4570 QCString memArgs;
4571 if (!isRelated())
4572 {
4573 if (isObjCMethod())
4574 {
4575 memName = "[" + pd->name() + " " + name() + "]";
4576 }
4577 else
4578 {
4579 if (pd!=Doxygen::globalScope) memName.prepend(pdName+sep);
4580 memArgs = argsString();
4581 }
4582 }
4583 const RefItemVector &xrefItems = xrefListItems();
4584 if (sep!="::")
4585 {
4586 memName = substitute(memName,"::",sep);
4587 }
4588 addRefItem(xrefItems,
4589 qualifiedName()+argsString(), // argsString is needed for overloaded functions (see bug 609624)
4590 memLabel,
4591 getOutputFileBase()+"#"+anchor(),memName,memArgs,pd);
4592}
4593
4595{
4596 auto it = m_sectionMap.find(container);
4597 return it!=m_sectionMap.end() ? it->second : nullptr;
4598}
4599
4601{
4602 //printf("MemberDefImpl::setSectionList(%s,%p) name=%s\n",qPrint(d->name()),sl,qPrint(name()));
4603 m_sectionMap.emplace(container,sl);
4604}
4605
4607{
4608 if (count>25)
4609 {
4611 "Internal inconsistency: recursion detected in overload relation for member {}!",name());
4612 return Specifier::Normal;
4613 }
4614 Specifier v = m_virt;
4615 const MemberDef *rmd = reimplements();
4616 while (rmd && v==Specifier::Normal)
4617 {
4618 v = rmd->virtualness(count+1)==Specifier::Normal ? Specifier::Normal : Specifier::Virtual;
4619 rmd = rmd->reimplements();
4620 }
4621 return v;
4622}
4623
4624void MemberDefImpl::writeTagFile(TextStream &tagFile,bool useQualifiedName,bool showNamespaceMembers) const
4625{
4626 if (!isLinkableInProject()) return;
4627 if (!showNamespaceMembers && getNamespaceDef()) return;
4628 tagFile << " <member kind=\"";
4629 switch (m_mtype)
4630 {
4631 case MemberType::Define: tagFile << "define"; break;
4632 case MemberType::EnumValue: tagFile << "enumvalue"; break;
4633 case MemberType::Property: tagFile << "property"; break;
4634 case MemberType::Event: tagFile << "event"; break;
4635 case MemberType::Variable: tagFile << "variable"; break;
4636 case MemberType::Typedef: tagFile << "typedef"; break;
4637 case MemberType::Enumeration: tagFile << "enumeration"; break;
4638 case MemberType::Function: tagFile << "function"; break;
4639 case MemberType::Signal: tagFile << "signal"; break;
4640 case MemberType::Friend: tagFile << "friend"; break;
4641 case MemberType::DCOP: tagFile << "dcop"; break;
4642 case MemberType::Slot: tagFile << "slot"; break;
4643 case MemberType::Interface: tagFile << "interface"; break;
4644 case MemberType::Service: tagFile << "service"; break;
4645 case MemberType::Sequence: tagFile << "sequence"; break;
4646 case MemberType::Dictionary: tagFile << "dictionary"; break;
4647 }
4648 if (m_prot!=Protection::Public)
4649 {
4650 tagFile << "\" protection=\"";
4651 if (m_prot==Protection::Protected) tagFile << "protected";
4652 else if (m_prot==Protection::Package) tagFile << "package";
4653 else /* Private */ tagFile << "private";
4654 }
4655 if (m_virt!=Specifier::Normal)
4656 {
4657 tagFile << "\" virtualness=\"";
4658 if (m_virt==Specifier::Virtual) tagFile << "virtual";
4659 else /* Pure */ tagFile << "pure";
4660 }
4661 if (isStatic())
4662 {
4663 tagFile << "\" static=\"yes";
4664 }
4665 tagFile << "\">\n";
4666 if (typeString()!=QCString("@"))
4667 {
4668 tagFile << " <type>" << convertToXML(typeString()) << "</type>\n";
4669 }
4672 tagFile << " <name>" << convertToXML(useQualifiedName ? qualifiedName() : name()) << "</name>\n";
4673 tagFile << " <anchorfile>" << convertToXML(fn) << "</anchorfile>\n";
4674 tagFile << " <anchor>" << convertToXML(anchor()) << "</anchor>\n";
4675 QCString idStr = id();
4676 if (!idStr.isEmpty())
4677 {
4678 tagFile << " <clangid>" << convertToXML(idStr) << "</clangid>\n";
4679 }
4680 tagFile << " <arglist>" << convertToXML(argsString()) << "</arglist>\n";
4681 if (isStrong())
4682 {
4683 for (const auto &fmd : m_enumFields)
4684 {
4685 if (!fmd->isReference())
4686 {
4687 tagFile << " <enumvalue file=\"" << convertToXML(fn);
4688 tagFile << "\" anchor=\"" << convertToXML(fmd->anchor());
4689 idStr = fmd->id();
4690 if (!idStr.isEmpty())
4691 {
4692 tagFile << "\" clangid=\"" << convertToXML(idStr);
4693 }
4694 tagFile << "\">" << convertToXML(fmd->name()) << "</enumvalue>\n";
4695 }
4696 }
4697 }
4698 writeDocAnchorsToTagFile(tagFile);
4699 tagFile << " </member>\n";
4700}
4701
4703{
4704 m_isConstructorCached=1; // FALSE
4705 if (getClassDef())
4706 {
4707 if (m_isDMember) // for D
4708 {
4709 m_isConstructorCached = name()=="this" ? 2 : 1;
4710 return;
4711 }
4712 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4713 {
4714 m_isConstructorCached = name()=="__construct" ? 2 : 1;
4715 return;
4716 }
4717 else if (name()=="__init__" &&
4718 getLanguage()==SrcLangExt::Python) // for Python
4719 {
4720 m_isConstructorCached = 2; // TRUE
4721 return;
4722 }
4723 else // for other languages
4724 {
4725 QCString locName = getClassDef()->localName();
4726 int i=locName.find('<');
4727 if (i==-1) // not a template class
4728 {
4729 m_isConstructorCached = name()==locName ? 2 : 1;
4730 }
4731 else
4732 {
4733 m_isConstructorCached = name()==locName.left(i) ? 2 : 1;
4734 }
4735 return;
4736 }
4737 }
4738}
4739
4741{
4742 if (m_isConstructorCached==0)
4743 {
4744 MemberDefImpl *that = const_cast<MemberDefImpl*>(this);
4745 that->_computeIsConstructor();
4746 }
4748 return m_isConstructorCached==2;
4749
4750}
4751
4753{
4754 bool isDestructor = false;
4755 if (m_isDMember) // for D
4756 {
4757 isDestructor = name()=="~this";
4758 }
4759 else if (getLanguage()==SrcLangExt::PHP) // for PHP
4760 {
4761 isDestructor = name()=="__destruct";
4762 }
4763 else if (name()=="__del__" &&
4764 getLanguage()==SrcLangExt::Python) // for Python
4765 {
4766 isDestructor = true;
4767 }
4768 else if (getLanguage()==SrcLangExt::Fortran) // for Fortran
4769 {
4770 isDestructor = typeString()=="final";
4771 }
4772 else // other languages
4773 {
4774 isDestructor =
4775 (name().find('~')!=-1 || name().find('!')!=-1) // The ! is for C++/CLI
4776 && name().find("operator")==-1;
4777 }
4779}
4780
4782{
4783 if (m_isDestructorCached==0)
4784 {
4785 MemberDefImpl *that=const_cast<MemberDefImpl*>(this);
4786 that->_computeIsDestructor();
4787 }
4789 return m_isDestructorCached==2;
4790}
4791
4793 const ClassDef *cd,const NamespaceDef *nd,const FileDef *fd,const GroupDef *gd,const ModuleDef *mod) const
4794{
4795 int enumMemCount=0;
4796
4797 uint32_t numVisibleEnumValues=0;
4798 for (const auto &fmd : m_enumFields)
4799 {
4800 if (fmd->isBriefSectionVisible()) numVisibleEnumValues++;
4801 }
4802 if (numVisibleEnumValues==0 && !isBriefSectionVisible())
4803 {
4804 return;
4805 }
4806
4807 QCString n = name();
4808 int i=n.findRev("::");
4809 if (i!=-1) n=n.right(n.length()-i-2); // strip scope (TODO: is this needed?)
4810 if (n[0]!='@') // not an anonymous enum
4811 {
4813 {
4814 //_writeTagData(compoundType);
4815 writeLink(typeDecl,cd,nd,fd,gd,mod);
4816 }
4817 else
4818 {
4819 typeDecl.startBold();
4820 typeDecl.docify(n);
4821 typeDecl.endBold();
4822 }
4823 typeDecl.writeChar(' ');
4824 }
4825 if (!m_enumBaseType.isEmpty())
4826 {
4827 typeDecl.writeChar(':');
4828 typeDecl.writeChar(' ');
4829 typeDecl.docify(m_enumBaseType);
4830 typeDecl.writeChar(' ');
4831 }
4832
4833 uint32_t enumValuesPerLine = static_cast<uint32_t>(Config_getInt(ENUM_VALUES_PER_LINE));
4834 if (numVisibleEnumValues>0 && enumValuesPerLine>0)
4835 {
4836 typeDecl.docify("{ ");
4837
4838 auto it = m_enumFields.begin();
4839 if (it!=m_enumFields.end())
4840 {
4841 const MemberDef *fmd=*it;
4842 bool fmdVisible = fmd->isBriefSectionVisible();
4843 bool first=true;
4844 while (fmd)
4845 {
4846 if (fmdVisible)
4847 {
4848 if (!first)
4849 {
4850 typeDecl.writeString(", ");
4851 }
4852 /* in html we start a new line after a number of items */
4853 if (numVisibleEnumValues>enumValuesPerLine
4854 && (enumMemCount%enumValuesPerLine)==0
4855 )
4856 {
4857 typeDecl.pushGeneratorState();
4859 typeDecl.enable(OutputType::Latex);
4860 typeDecl.enable(OutputType::Docbook);
4861 typeDecl.lineBreak();
4862 typeDecl.disable(OutputType::Latex);
4863 typeDecl.disable(OutputType::Docbook);
4864 typeDecl.writeString("&#160;&#160;");
4865 typeDecl.popGeneratorState();
4866 }
4867
4868 if (fmd->hasDocumentation()) // enum value has docs
4869 {
4870 fmd->writeLink(typeDecl,cd,nd,fd,gd,mod);
4871 }
4872 else // no docs for this enum value
4873 {
4874 typeDecl.startBold();
4875 typeDecl.docify(fmd->name());
4876 typeDecl.endBold();
4877 }
4878 if (fmd->hasOneLineInitializer()) // enum value has initializer
4879 {
4880 //typeDecl.writeString(" = ");
4881 typeDecl.writeString(" ");
4882 typeDecl.parseText(fmd->initializer());
4883 }
4884 first=false;
4885 }
4886
4887 bool prevVisible = fmdVisible;
4888 ++it;
4889 if (it!=m_enumFields.end())
4890 {
4891 fmd=*it;
4892 }
4893 else
4894 {
4895 fmd=nullptr;
4896 }
4897 if (prevVisible)
4898 {
4899 typeDecl.disable(OutputType::Man);
4900 typeDecl.writeString("\n"); // to prevent too long lines in LaTeX
4901 typeDecl.enable(OutputType::Man);
4902 enumMemCount++;
4903 }
4904 }
4905 if (numVisibleEnumValues>enumValuesPerLine)
4906 {
4907 typeDecl.pushGeneratorState();
4909 typeDecl.lineBreak();
4910 typeDecl.popGeneratorState();
4911 }
4912 }
4913 typeDecl.docify(" }");
4914 }
4915}
4916
4917void MemberDefImpl::moveArgumentList(std::unique_ptr<ArgumentList> al)
4918{
4919 m_defArgList = *al;
4920}
4921
4922void MemberDefImpl::moveDeclArgumentList(std::unique_ptr<ArgumentList> al)
4923{
4924 m_declArgList = *al;
4925}
4926
4931
4933{
4934 m_type = t;
4935}
4936
4938{
4939 m_accessorClass = cd;
4940 m_accessorType = t;
4941}
4942
4947
4954
4960
4966
4972
4978
4983
4988
4990{
4991 if (getClassDef() && getClassDef()->isObjectiveC() && isFunction()) return TRUE;
4992 return FALSE;
4993}
4994
4996{
4997 if (getClassDef() && getClassDef()->isObjectiveC() && isProperty()) return TRUE;
4998 return FALSE;
4999}
5000
5002{
5003 if (getClassDef() && getClassDef()->isCSharp() && isProperty()) return TRUE;
5004 return FALSE;
5005}
5006
5008{
5009 if (isObjCMethod())
5010 {
5011 QCString qm;
5012 if (isStatic()) qm="+"; else qm="-";
5013 qm+="[";
5014 qm+=getClassDef()->name()+" ";
5015 qm+=name();
5016 qm+="]";
5017 return qm;
5018 }
5019 else if (m_enumScope && m_enumScope->isStrong())
5020 {
5021 return m_enumScope->qualifiedName()+
5023 localName();
5024 }
5025 else
5026 {
5028 }
5029}
5030
5032{
5033 if (ti)
5034 {
5035 //printf("%s: Setting tag name=%s anchor=%s\n",qPrint(name()),qPrint(ti->tagName),qPrint(ti->anchor));
5036 m_anc=ti->anchor;
5037 setReference(ti->tagName);
5039 }
5040}
5041
5042QCString MemberDefImpl::objCMethodName(bool localLink,bool showStatic) const
5043{
5044 QCString qm;
5045 if (showStatic)
5046 {
5047 if (isStatic()) qm="+ "; else qm="- ";
5048 }
5049 qm+=name();
5050 if (!localLink) // link to method of same class
5051 {
5052 qm+=" (";
5053 qm+=getClassDef()->name();
5054 qm+=")";
5055 }
5056 return qm;
5057}
5058
5060{
5061 return m_decl;
5062}
5063
5065{
5066 return m_def;
5067}
5068
5073
5075{
5076 return m_type;
5077}
5078
5080{
5081 return m_args;
5082}
5083
5085{
5086 return m_exception;
5087}
5088
5090{
5091 return m_bitfields;
5092}
5093
5095{
5096 return m_initializer;
5097}
5098
5100{
5101 return m_initLines;
5102}
5103
5108
5113
5115{
5116 return m_classDef;
5117}
5118
5123
5128
5130{
5131 return m_fileDef;
5132}
5133
5135{
5136 return m_fileDef;
5137}
5138
5140{
5141 return m_nspace;
5142}
5143
5148
5150{
5151 return m_read;
5152}
5153
5155{
5156 return m_write;
5157}
5158
5160{
5161 return m_group;
5162}
5163
5165{
5166 return m_group;
5167}
5168
5170{
5171 return m_moduleDef;
5172}
5173
5178
5183
5185{
5186 return m_groupStartLine;
5187}
5188
5190{
5191 return m_groupHasDocs;
5192}
5193
5195{
5196 return m_prot;
5197}
5198
5200{
5201 return m_mtype;
5202}
5203
5205{
5207}
5208
5210{
5211 return m_mtype==MemberType::Slot;
5212}
5213
5215{
5217}
5218
5220{
5222}
5223
5225{
5227}
5228
5230{
5232}
5233
5235{
5237}
5238
5240{
5242}
5243
5245{
5247}
5248
5250{
5251 return m_mtype==MemberType::Variable && QCString(argsString()).find(")(")!=-1;
5252}
5253
5255{
5257}
5258
5260{
5262}
5263
5265{
5266 return m_mtype==MemberType::DCOP;
5267}
5268
5270{
5272}
5273
5275{
5276 return m_mtype==MemberType::Event;
5277}
5278
5280{
5281 return m_related == Relationship::Related;
5282}
5283
5285{
5286 return m_related == Relationship::Foreign;
5287}
5288
5290{
5291 return m_stat;
5292}
5293
5295{
5296 return m_memSpec.isInline();
5297}
5298
5300{
5301 return m_memSpec.isExplicit();
5302}
5303
5305{
5306 return m_memSpec.isMutable();
5307}
5308
5310{
5311 return m_memSpec.isThreadLocal();
5312}
5313
5315{
5316 return m_memSpec.isGettable();
5317}
5318
5320{
5321 return m_memSpec.isPrivateGettable();
5322}
5323
5325{
5326 return m_memSpec.isProtectedGettable();
5327}
5328
5330{
5331 return m_memSpec.isSettable();
5332}
5333
5335{
5336 return m_memSpec.isPrivateSettable();
5337}
5338
5340{
5341 return m_memSpec.isProtectedSettable();
5342}
5343
5345{
5346 return m_memSpec.isAddable();
5347}
5348
5350{
5351 return m_memSpec.isRemovable();
5352}
5353
5355{
5356 return m_memSpec.isRaisable();
5357}
5358
5360{
5361 return m_memSpec.isReadable();
5362}
5363
5365{
5366 return m_memSpec.isWritable();
5367}
5368
5370{
5371 return m_memSpec.isFinal();
5372}
5373
5375{
5376 return m_memSpec.isNew();
5377}
5378
5380{
5381 return m_memSpec.isSealed();
5382}
5383
5385{
5386 return m_memSpec.isOverride();
5387}
5388
5390{
5391 return m_memSpec.isInitonly();
5392}
5393
5395{
5396 return m_memSpec.isAbstract();
5397}
5398
5400{
5401 return m_memSpec.isOptional();
5402}
5403
5405{
5406 return m_memSpec.isRequired();
5407}
5408
5410{
5411 return m_memSpec.isNonAtomic();
5412}
5413
5415{
5416 return m_memSpec.isCopy();
5417}
5418
5420{
5421 return m_memSpec.isAssign();
5422}
5423
5425{
5426 return m_memSpec.isRetain();
5427}
5428
5430{
5431 return m_memSpec.isWeak();
5432}
5433
5435{
5436 return m_memSpec.isStrong();
5437}
5438
5440{
5441 return m_memSpec.isEnumStruct();
5442}
5443
5445{
5447 m_enumScope &&
5448 m_enumScope->isStrong();
5449}
5450
5452{
5453 return m_memSpec.isUnretained();
5454}
5455
5457{
5458 return m_memSpec.isAlias();
5459}
5460
5462{
5463 return m_memSpec.isDefault();
5464}
5465
5467{
5468 return m_memSpec.isDelete();
5469}
5470
5472{
5473 return m_memSpec.isNoExcept();
5474}
5475
5477{
5478 return m_memSpec.isAttribute();
5479}
5480
5482{
5483 return m_memSpec.isProperty();
5484}
5485
5487{
5488 return m_memSpec.isReadonly();
5489}
5490
5492{
5493 return m_memSpec.isBound();
5494}
5495
5497{
5498 return m_memSpec.isConstrained();
5499}
5500
5502{
5503 return m_memSpec.isTransient();
5504}
5505
5507{
5508 return m_memSpec.isMaybeVoid();
5509}
5510
5512{
5513 return m_memSpec.isMaybeDefault();
5514}
5515
5517{
5518 return m_memSpec.isMaybeAmbiguous();
5519}
5520
5522{
5523 return m_memSpec.isPublished();
5524}
5525
5526
5528{
5529 return m_implOnly;
5530}
5531
5533{
5534 return m_explExt;
5535}
5536
5538{
5539 return m_tspec;
5540}
5541
5543{
5544 return isFunction() ||
5545 isSlot() ||
5546 isSignal() ||
5547 isConstructor() ||
5548 isDestructor() ||
5549 isObjCMethod() ||
5550 isFriend();
5551}
5552
5554{
5555 return m_relatedAlso;
5556}
5557
5559{
5560 return m_docEnumValues;
5561}
5562
5564{
5565 return m_annEnumType;
5566}
5567
5569{
5570 return m_docsForDefinition;
5571}
5572
5574{
5575 return m_enumScope;
5576}
5577
5579{
5580 return m_livesInsideEnum;
5581}
5582
5584{
5585 return m_memSpec.isLocal();
5586}
5587
5589{
5590 return m_memSpec.isNoDiscard();
5591}
5592
5594{
5595 return m_memSpec.isConstExpr();
5596}
5597
5599{
5600 return m_memSpec.isConstEval();
5601}
5602
5604{
5605 return m_memSpec.isConstInit();
5606}
5607
5609{
5610 return m_enumFields;
5611}
5612
5614{
5615 return m_examples;
5616}
5617
5619{
5620 return m_proto;
5621}
5622
5624{
5625 return m_defArgList;
5626}
5627
5629{
5630 return m_declArgList;
5631}
5632
5634{
5635 ArgumentList &decAl = m_declArgList;
5636 ArgumentList &defAl = m_defArgList;
5637 const ArgumentList &decAlSrc = md->declArgumentList();
5638 const ArgumentList &defAlSrc = md->argumentList();
5639 auto decSrc = decAlSrc.begin(), defSrc = defAlSrc.begin();
5640 for (auto decIt = decAl.begin(), defIt = defAl.begin();
5641 decIt != decAl.end() && defIt != defAl.end() && decSrc != decAlSrc.end() && defSrc != defAlSrc.end();
5642 ++decIt, ++defIt, ++decSrc, ++defSrc++)
5643 {
5644 Argument &decA = *decIt;
5645 Argument &defA = *defIt;
5646 const Argument &decAS = *decSrc;
5647 const Argument &defAS = *defSrc;
5648 if (decA.name.isEmpty())
5649 {
5650 if (!defA.name.isEmpty())
5651 {
5652 decA.name = defA.name;
5653 }
5654 else if (!decAS.name.isEmpty())
5655 {
5656 decA.name = decAS.name;
5657 }
5658 else if (!defAS.name.isEmpty())
5659 {
5660 decA.name = defAS.name;
5661 }
5662 }
5663 if (defA.name.isEmpty())
5664 {
5665 if (!decA.name.isEmpty())
5666 {
5667 defA.name = decA.name;
5668 }
5669 else if (!decAS.name.isEmpty())
5670 {
5671 defA.name = decAS.name;
5672 }
5673 else if (!defAS.name.isEmpty())
5674 {
5675 defA.name = defAS.name;
5676 }
5677 }
5678 }
5679}
5680
5682{
5683 return m_tArgList;
5684}
5685
5690
5692{
5693 return m_grpId;
5694}
5695
5700
5702{
5703 return m_annScope;
5704}
5705
5707{
5708 return m_hasCallGraph;
5709}
5710
5712{
5713 bool enabled = m_hasCallGraph &&
5714 (isFunction() || isSlot() || isSignal()) &&
5715 Config_getBool(HAVE_DOT);
5716 if (enabled)
5717 {
5718 bool trivial = DotCallGraph::isTrivial(this,FALSE);
5719 return !trivial;
5720 }
5721 return FALSE;
5722}
5723
5725{
5726 return m_hasCallerGraph;
5727}
5728
5730{
5731 bool enabled = m_hasCallerGraph &&
5732 (isFunction() || isSlot() || isSignal()) &&
5733 Config_getBool(HAVE_DOT);
5734 if (enabled)
5735 {
5736 bool trivial = DotCallGraph::isTrivial(this,TRUE);
5737 return !trivial;
5738 }
5739 return FALSE;
5740}
5741
5746
5751
5753{
5754 return m_hasInlineSource;
5755}
5756
5758{
5759 return m_hasEnumValues;
5760}
5761
5763{
5764 return m_templateMaster;
5765}
5766
5767std::optional<ArgumentList> MemberDefImpl::formalTemplateArguments() const
5768{
5770}
5771
5773{
5774 return m_isTypedefValCached;
5775}
5776
5781
5786
5788{
5789 //printf("MemberDefImpl::getCachedResolvedTypedef()=%s\n",qPrint(m_cachedResolvedType));
5790 return m_cachedResolvedType;
5791}
5792
5794{
5795 return m_memDef;
5796}
5797
5799{
5800 return m_memDec;
5801}
5802
5804{
5805 return m_docProvider;
5806}
5807
5809{
5810 return m_groupAlias;
5811}
5812
5817
5819{
5820 return m_declLine;
5821}
5822
5824{
5825 return m_declColumn;
5826}
5827
5828
5829//----------------------------------------------
5830
5836
5838{
5839 m_def=d;
5840}
5841
5849
5851{
5852 m_moduleDef=mod;
5853}
5854
5860
5865
5870
5875
5880
5882{
5883 for (const auto &sx : qualifiers)
5884 {
5885 bool alreadyAdded = std::find(m_qualifiers.begin(), m_qualifiers.end(), sx) != m_qualifiers.end();
5886 if (!alreadyAdded)
5887 {
5888 m_qualifiers.push_back(sx);
5889 }
5890 }
5891}
5892
5897
5899{
5900 if (lines!=-1)
5901 {
5902 m_userInitLines=lines;
5903 }
5904}
5905
5907{
5908 m_read=r;
5909}
5910
5912{
5913 m_write=w;
5914}
5915
5917{
5918 m_tspec=b;
5919}
5920
5922{
5923 m_related = Relationship::Related;
5925}
5926
5928{
5929 m_related = Relationship::Foreign;
5931}
5932
5934{
5935 m_docProvider = md;
5936}
5937
5939{
5940 m_args = as;
5941}
5942
5947
5954
5956{
5957 m_docEnumValues=value;
5958}
5959
5961{
5962 m_annEnumType = md;
5963}
5964
5965void MemberDefImpl::setPrototype(bool p,const QCString &df,int line,int column)
5966{
5967 m_proto=p;
5968 if (p)
5969 {
5970 setDeclFile(df,line,column);
5971 }
5972 else
5973 {
5974 setDefFile(df,line,column);
5975 }
5976}
5977
5978void MemberDefImpl::setExplicitExternal(bool b,const QCString &df,int line,int column)
5979{
5980 m_explExt=b;
5981 if (b)
5982 {
5983 setDeclFile(df,line,column);
5984 }
5985 else
5986 {
5987 setDefFile(df,line,column);
5988 }
5989}
5990
5991void MemberDefImpl::setDeclFile(const QCString &df,int line,int column)
5992{
5993 m_declFileName = df;
5994 m_declLine = line;
5995 m_declColumn = column;
5996}
5997
5999{
6000 m_grpId=id;
6001}
6002
6007
6009{
6010 m_annScope=b;
6011}
6012
6017
6022
6028
6033
6038
6040{
6041 m_groupAlias = md;
6042}
6043
6048
6053
6058
6060{
6061 return m_category;
6062}
6063
6065{
6066 m_category = def;
6067}
6068
6070{
6071 return m_categoryRelation;
6072}
6073
6078
6080{
6081 m_enumBaseType = type;
6082}
6083
6085{
6086 return m_enumBaseType;
6087}
6088
6090{
6091 m_requiresClause = req;
6092}
6093
6098
6099void MemberDefImpl::cacheTypedefVal(const ClassDef*val, const QCString & templSpec, const QCString &resolvedType)
6100{
6103 m_cachedTypedefTemplSpec=templSpec;
6104 m_cachedResolvedType=resolvedType;
6105 //printf("MemberDefImpl::cacheTypedefVal=%s m_impl=%p\n",qPrint(m_cachedResolvedType),m_impl);
6106}
6107
6109{
6110 {
6111 const ArgumentList &srcAl = bmd->argumentList();
6112 ArgumentList &dstAl = m_defArgList;
6113 auto srcIt = srcAl.begin();
6114 auto dstIt = dstAl.begin();
6115 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6116 {
6117 Argument &argDst = *dstIt;
6118 const Argument &argSrc = *srcIt;
6119 argDst.name = argSrc.name;
6120 argDst.docs = argSrc.docs;
6121 ++srcIt;
6122 ++dstIt;
6123 }
6124 }
6125
6126 {
6127 const ArgumentList &srcAl = bmd->declArgumentList();
6128 ArgumentList &dstAl = m_declArgList;
6129 auto srcIt = srcAl.begin();
6130 auto dstIt = dstAl.begin();
6131
6132 while ( srcIt!=srcAl.end() && dstIt!=dstAl.end())
6133 {
6134 Argument &argDst = *dstIt;
6135 const Argument &argSrc = *srcIt;
6136 argDst.name = argSrc.name;
6137 argDst.docs = argSrc.docs;
6138 ++srcIt;
6139 ++dstIt;
6140 }
6141 }
6142}
6143
6145{
6146 for (Argument &a : al)
6147 {
6148 a.canType.clear();
6149 }
6150}
6151
6157
6162
6164{
6165 return m_numberOfFlowKW;
6166}
6167
6168//----------------
6169
6171{
6172 return DefinitionMixin::name();
6173}
6174
6175//----------------
6176
6178{
6179 for (auto decIt = decAl.begin(), defIt = defAl.begin();
6180 decIt!= decAl.end() && defIt!= defAl.end();
6181 ++decIt, ++defIt)
6182 {
6183 Argument &decA = *decIt;
6184 Argument &defA = *defIt;
6185 if (decA.docs.isEmpty() && !defA.docs.isEmpty())
6186 {
6187 decA.docs = defA.docs;
6188 }
6189 else if (defA.docs.isEmpty() && !decA.docs.isEmpty())
6190 {
6191 defA.docs = decA.docs;
6192 }
6193 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6194 {
6195 if (decA.name.isEmpty() && !defA.name.isEmpty())
6196 {
6197 decA.name = defA.name;
6198 }
6199 else if (defA.name.isEmpty() && !decA.name.isEmpty())
6200 {
6201 defA.name = decA.name;
6202 }
6203 }
6204 }
6205}
6206
6208{
6209 AUTO_TRACE("mdec='{}' mdef='{}' mdec.isPrototype={} mdef.isPrototype={}",
6210 mdec->name(), mdef->name(), mdec->isPrototype(), mdef->isPrototype());
6211 if (
6212 (mdef->isFunction() && !mdef->isStatic() && !mdef->isPrototype()) ||
6213 (mdef->isVariable() && !mdef->isExternal() && !mdef->isStatic())
6214 )
6215 {
6216 bool sameNumTemplateArgs = mdef->templateArguments().size()==mdec->templateArguments().size();
6217
6218 ArgumentList &mdefAl = const_cast<ArgumentList&>(mdef->argumentList());
6219 ArgumentList &mdecAl = const_cast<ArgumentList&>(mdec->argumentList());
6220 if (sameNumTemplateArgs &&
6221 matchArguments2(mdef->getOuterScope(),mdef->getFileDef(),&mdefAl,
6222 mdec->getOuterScope(),mdec->getFileDef(),&mdecAl,
6223 TRUE,mdef->getLanguage()
6224 )
6225 ) /* match found */
6226 {
6227 AUTO_TRACE_ADD("combining definition and declaration");
6228
6229 if (Config_getBool(RESOLVE_UNNAMED_PARAMS))
6230 {
6231 mdec->resolveUnnamedParameters(mdef);
6232 }
6233
6234 // first merge argument documentation
6235 transferArgumentDocumentation(mdecAl,mdefAl);
6236
6237 /* copy documentation between function definition and declaration */
6238 if (!mdec->briefDescription().isEmpty())
6239 {
6240 mdef->setBriefDescription(mdec->briefDescription(),mdec->briefFile(),mdec->briefLine());
6241 }
6242 else if (!mdef->briefDescription().isEmpty())
6243 {
6244 mdec->setBriefDescription(mdef->briefDescription(),mdef->briefFile(),mdef->briefLine());
6245 }
6246 if (!mdef->documentation().isEmpty())
6247 {
6248 //printf("transferring docs mdef->mdec (%s->%s)\n",mdef->argsString(),mdec->argsString());
6249 mdec->setDocumentation(mdef->documentation(),mdef->docFile(),mdef->docLine());
6251 if (mdefAl.hasParameters())
6252 {
6253 auto mdefAlComb = stringToArgumentList(mdef->getLanguage(),mdef->argsString());
6254 transferArgumentDocumentation(mdefAl,*mdefAlComb);
6255 mdec->moveArgumentList(std::move(mdefAlComb));
6256 }
6257 }
6258 else if (!mdec->documentation().isEmpty())
6259 {
6260 //printf("transferring docs mdec->mdef (%s->%s)\n",mdec->argsString(),mdef->argsString());
6261 mdef->setDocumentation(mdec->documentation(),mdec->docFile(),mdec->docLine());
6263 if (mdecAl.hasParameters())
6264 {
6265 auto mdecAlComb = stringToArgumentList(mdec->getLanguage(),mdec->argsString());
6266 transferArgumentDocumentation(mdecAl,*mdecAlComb);
6267 mdef->moveDeclArgumentList(std::move(mdecAlComb));
6268 }
6269 }
6270 if (!mdef->inbodyDocumentation().isEmpty())
6271 {
6272 mdec->setInbodyDocumentation(mdef->inbodyDocumentation(),mdef->inbodyFile(),mdef->inbodyLine());
6273 }
6274 else if (!mdec->inbodyDocumentation().isEmpty())
6275 {
6276 mdef->setInbodyDocumentation(mdec->inbodyDocumentation(),mdec->inbodyFile(),mdec->inbodyLine());
6277 }
6278 if (mdec->getStartBodyLine()!=-1 && mdef->getStartBodyLine()==-1)
6279 {
6280 //printf("body mdec->mdef %d-%d\n",mdec->getStartBodyLine(),mdef->getEndBodyLine());
6281 mdef->setBodySegment(mdec->getDefLine(),mdec->getStartBodyLine(),mdec->getEndBodyLine());
6282 mdef->setBodyDef(mdec->getBodyDef());
6283 //mdef->setBodyMember(mdec);
6284 }
6285 else if (mdef->getStartBodyLine()!=-1 && mdec->getStartBodyLine()==-1)
6286 {
6287 //printf("body mdef->mdec %d-%d\n",mdef->getStartBodyLine(),mdec->getEndBodyLine());
6288 mdec->setBodySegment(mdef->getDefLine(),mdef->getStartBodyLine(),mdef->getEndBodyLine());
6289 mdec->setBodyDef(mdef->getBodyDef());
6290 //mdec->setBodyMember(mdef);
6291 }
6294
6295 // copy group info.
6296 if (mdec->getGroupDef()==nullptr && mdef->getGroupDef()!=nullptr)
6297 {
6298 mdec->setGroupDef(mdef->getGroupDef(),
6299 mdef->getGroupPri(),
6300 mdef->docFile(),
6301 mdef->docLine(),
6302 mdef->hasDocumentation(),
6303 mdef
6304 );
6305 }
6306 else if (mdef->getGroupDef()==nullptr && mdec->getGroupDef()!=nullptr)
6307 {
6308 mdef->setGroupDef(mdec->getGroupDef(),
6309 mdec->getGroupPri(),
6310 mdec->docFile(),
6311 mdec->docLine(),
6312 mdec->hasDocumentation(),
6313 mdec
6314 );
6315 }
6316
6317
6318 mdec->mergeRefItems(mdef);
6319 mdef->mergeRefItems(mdec);
6320
6321 mdef->setMemberDeclaration(mdec);
6322 mdec->setMemberDefinition(mdef);
6323
6324 mergeMemberOverrideOptions(mdec,mdef);
6325
6326 mdef->addQualifiers(mdec->getQualifiers());
6327 mdec->addQualifiers(mdef->getQualifiers());
6328 }
6329 }
6330}
6331
6333{
6334 if (m_templateMaster)
6335 {
6336 return m_templateMaster->briefDescription(abbr);
6337 }
6338 else
6339 {
6341 }
6342}
6343
6345{
6346 if (m_templateMaster)
6347 {
6348 return m_templateMaster->documentation();
6349 }
6350 else
6351 {
6353 }
6354}
6355
6357{
6358 if (m_templateMaster)
6359 {
6360 return m_templateMaster->hasUserDocumentation();
6361 }
6362 else
6363 {
6365 }
6366}
6367
6369{
6370 return m_typeConstraints;
6371}
6372
6374{
6375 bool hideFriendCompounds = Config_getBool(HIDE_FRIEND_COMPOUNDS);
6376 bool isFriendToHide = hideFriendCompounds &&
6377 (m_type=="friend class" ||
6378 m_type=="friend struct" ||
6379 m_type=="friend union");
6380 return isFriendToHide;
6381}
6382
6384{
6385 return (isFriend() &&
6386 (m_type=="friend class" || m_type=="friend struct" ||
6387 m_type=="friend union"));
6388}
6389
6390
6392{
6393 return !(isFriend() && isFriendToHide());
6394}
6395
6397{
6398 return isFunction() || isSlot() || isSignal();
6399}
6400
6402{
6403 return isRelated() || isForeign() || (isFriend() && !isFriendToHide());
6404}
6405
6407{
6409 (m_templateMaster && m_templateMaster->isReference());
6410}
6411
6435
6437{
6438 return m_redefineCount;
6439}
6440
6442{
6443 m_redefineCount=count;
6444}
6445
6446//-------------------------------------------------------------------------------
6447// Helpers
6448
6450
6452{
6453 MemberDefMutable *src = toMemberDefMutable(const_cast<MemberDef*>(s));
6454 MemberDefMutable *dst = toMemberDefMutable(const_cast<MemberDef*>(d));
6455 if (src==nullptr || dst==nullptr) return;
6456 //printf("--> addDocCrossReference src=%s,dst=%s\n",qPrint(src->name()),qPrint(dst->name()));
6457 if (dst->isTypedef() || dst->isEnumerate()) return; // don't add types
6458 if ((dst->hasReferencedByRelation() || dst->hasCallerGraph()) &&
6459 src->isCallable()
6460 )
6461 {
6462 QCString sourceRefName = src->sourceRefName();
6465
6466 // ---- critical section
6467 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6468 dst->addSourceReferencedBy(src,sourceRefName);
6469 if (mdDef)
6470 {
6471 mdDef->addSourceReferencedBy(src,sourceRefName);
6472 }
6473 if (mdDecl)
6474 {
6475 mdDecl->addSourceReferencedBy(src,sourceRefName);
6476 }
6477 // ---- end critical section
6478 }
6479 if ((src->hasReferencesRelation() || src->hasCallGraph()) &&
6480 src->isCallable()
6481 )
6482 {
6483 QCString sourceRefName = dst->sourceRefName();
6486
6487 // ---- critical section
6488 std::lock_guard<std::mutex> lock(g_docCrossReferenceMutex);
6489 src->addSourceReferences(dst,sourceRefName);
6490 if (mdDef)
6491 {
6492 mdDef->addSourceReferences(dst,sourceRefName);
6493 }
6494 if (mdDecl)
6495 {
6496 mdDecl->addSourceReferences(dst,sourceRefName);
6497 }
6498 // ---- end critical section
6499 }
6500}
6501
6502// --- Cast functions
6503//
6505{
6506 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6507 {
6508 return static_cast<MemberDef*>(d);
6509 }
6510 else
6511 {
6512 return nullptr;
6513 }
6514}
6515
6517{
6518 Definition *d = toDefinition(md);
6519 if (d && typeid(*d)==typeid(MemberDefImpl))
6520 {
6521 return static_cast<MemberDef*>(d);
6522 }
6523 else
6524 {
6525 return nullptr;
6526 }
6527}
6528
6530{
6531 if (d && (typeid(*d)==typeid(MemberDefImpl) || typeid(*d)==typeid(MemberDefAliasImpl)))
6532 {
6533 return static_cast<const MemberDef*>(d);
6534 }
6535 else
6536 {
6537 return nullptr;
6538 }
6539}
6540
6542{
6543 if (d && typeid(*d)==typeid(MemberDefImpl))
6544 {
6545 return static_cast<MemberDefMutable*>(d);
6546 }
6547 else
6548 {
6549 return nullptr;
6550 }
6551}
6552
6553
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:8955
static void writeTagFile()
FileDef * toFileDef(Definition *d)
Definition filedef.cpp:1954
GroupDef * toGroupDef(Definition *d)
Translator * theTranslator
Definition language.cpp:71
static QCString simplifyTypeForTable(const QCString &s)
static void writeExceptionList(OutputList &ol, const ClassDef *cd, const MemberDef *md)
static void writeExceptionListImpl(OutputList &ol, const ClassDef *cd, const MemberDef *md, QCString const &exception)
static QCString stripTrailingReturn(const QCString &trailRet)
static QCString combineArgsAndException(QCString args, QCString exception)
static bool writeDefArgumentList(OutputList &ol, const Definition *scope, const MemberDef *md)
static std::mutex g_hasDetailedDescriptionMutex
static std::mutex g_docCrossReferenceMutex
std::unique_ptr< MemberDef > createMemberDefAlias(const Definition *newScope, const MemberDef *aliasMd)
static void invalidateCachedTypesInArgumentList(ArgumentList &al)
static std::mutex g_detectUndocumentedParamsMutex
static void transferArgumentDocumentation(ArgumentList &decAl, ArgumentList &defAl)
void addDocCrossReference(const MemberDef *s, const MemberDef *d)
static std::mutex g_cachedAnonymousTypeMutex
MemberDefMutable * toMemberDefMutable(Definition *d)
void combineDeclarationAndDefinition(MemberDefMutable *mdec, MemberDefMutable *mdef)
static QCString addTemplateNames(const QCString &s, const QCString &n, const QCString &t)
MemberDef * toMemberDef(Definition *d)
static const reg::Ex reAnonymous(R"([\w:@]*@\d+)")
std::unique_ptr< MemberDef > createMemberDef(const QCString &defFileName, int defLine, int defColumn, const QCString &type, const QCString &name, const QCString &args, const QCString &excp, Protection prot, Specifier virt, bool stat, Relationship related, MemberType t, const ArgumentList &tal, const ArgumentList &al, const QCString &metaData)
Factory method to create a new instance of a MemberDef.
#define warn_undoc(file, line, fmt,...)
Definition message.h:102
#define warn_uncond(fmt,...)
Definition message.h:122
#define warn(file, line, fmt,...)
Definition message.h:97
#define msg(fmt,...)
Definition message.h:94
#define err(fmt,...)
Definition message.h:127
#define warn_doc_error(file, line, fmt,...)
Definition message.h:112
ModuleDef * toModuleDef(Definition *d)
NamespaceDef * toNamespaceDef(Definition *d)
bool search(std::string_view str, Match &match, const Ex &re, size_t pos)
Search in a given string str starting at position pos for a match against regular expression re.
Definition regex.cpp:778
QCString substitute(const QCString &s, const QCString &src, const QCString &dst)
substitute all occurrences of src in s by dst
Definition qcstring.cpp:482
#define qsnprintf
Definition qcstring.h:49
#define TRUE
Definition qcstring.h:37
#define FALSE
Definition qcstring.h:34
uint32_t qstrlen(const char *str)
Returns the length of string str, or 0 if a null pointer is passed.
Definition qcstring.h:58
#define ASSERT(x)
Definition qcstring.h:39
std::vector< RefItem * > RefItemVector
Definition reflist.h:133
Web server based search engine.
std::string_view stripWhiteSpace(std::string_view s)
Given a string view s, returns a new, narrower view on that string, skipping over any leading or trai...
Definition stringutil.h:72
This class contains the information about the argument of a function or template.
Definition arguments.h:27
QCString type
Definition arguments.h:42
QCString name
Definition arguments.h:44
QCString defval
Definition arguments.h:46
QCString docs
Definition arguments.h:47
QCString array
Definition arguments.h:45
QCString attrib
Definition arguments.h:41
Data associated with an example.
Definition example.h:29
GroupPri_t
Grouping priority.
Definition types.h:230
@ GROUPING_AUTO_DEF
membership in group was defined via @defgroup
Definition types.h:234
This struct is used to capture the tag file information for an Entry.
Definition entry.h:103
QCString anchor
Definition entry.h:106
QCString fileName
Definition entry.h:105
QCString tagName
Definition entry.h:104
CodeSymbolType
Definition types.h:481
MemberType
Definition types.h:552
@ Enumeration
Definition types.h:557
@ EnumValue
Definition types.h:558
@ Dictionary
Definition types.h:568
@ Interface
Definition types.h:565
@ Sequence
Definition types.h:567
@ Variable
Definition types.h:555
@ Property
Definition types.h:563
@ Typedef
Definition types.h:556
@ Function
Definition types.h:554
@ Service
Definition types.h:566
MemberListContainer
Definition types.h:472
Protection
Definition types.h:32
SrcLangExt
Definition types.h:207
Relationship
Definition types.h:167
Specifier
Definition types.h:80
VhdlSpecifier
Definition types.h:710
QCString removeRedundantWhiteSpace(const QCString &s)
Definition util.cpp:576
SrcLangExt getLanguageFromFileName(const QCString &fileName, SrcLangExt defLang)
Definition util.cpp:5107
bool protectionLevelVisible(Protection prot)
Definition util.cpp:5849
QCString substituteTemplateArgumentsInString(const QCString &nm, const ArgumentList &formalArgs, const ArgumentList *actualArgs)
Definition util.cpp:4275
void writeTypeConstraints(OutputList &ol, const Definition *d, const ArgumentList &al)
Definition util.cpp:5355
QCString stripAnonymousNamespaceScope(const QCString &s)
Definition util.cpp:239
QCString stripFromIncludePath(const QCString &path)
Definition util.cpp:338
QCString tempArgListToString(const ArgumentList &al, SrcLangExt lang, bool includeDefault)
Definition util.cpp:1244
void addRefItem(const RefItemVector &sli, const QCString &key, const QCString &prefix, const QCString &name, const QCString &title, const QCString &args, const Definition *scope)
Definition util.cpp:4726
void writePageRef(OutputList &ol, const QCString &cn, const QCString &mn)
Definition util.cpp:268
QCString removeAnonymousScopes(const QCString &str)
Definition util.cpp:170
bool matchArguments2(const Definition *srcScope, const FileDef *srcFileScope, const ArgumentList *srcAl, const Definition *dstScope, const FileDef *dstFileScope, const ArgumentList *dstAl, bool checkCV, SrcLangExt lang)
Definition util.cpp:1956
QCString inlineTemplateArgListToDoc(const ArgumentList &al)
Definition util.cpp:1172
QCString stripExtension(const QCString &fName)
Definition util.cpp:4845
QCString convertToXML(const QCString &s, bool keepEntities)
Definition util.cpp:3833
QCString getLanguageSpecificSeparator(SrcLangExt lang, bool classScope)
Returns the scope separator to use given the programming language lang.
Definition util.cpp:5809
void mergeMemberOverrideOptions(MemberDefMutable *md1, MemberDefMutable *md2)
Definition util.cpp:6771
void writeMarkerList(OutputList &ol, const std::string &markerText, size_t numMarkers, std::function< void(size_t)> replaceFunc)
Definition util.cpp:1101
QCString inlineArgListToDoc(const ArgumentList &al)
Definition util.cpp:1154
void linkifyText(const TextGeneratorIntf &out, const Definition *scope, const FileDef *fileScope, const Definition *self, const QCString &text, bool autoBreak, bool external, bool keepSpaces, int indentLevel)
Definition util.cpp:902
void writeExamples(OutputList &ol, const ExampleList &list)
Definition util.cpp:1125
void addHtmlExtensionIfMissing(QCString &fName)
Definition util.cpp:4823
A bunch of utility functions.
bool isId(int c)
Definition util.h:208