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