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