1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/******************************************************************************
*
* $Id$
*
* Copyright (C) 1997-1999 by Dimitri van Heesch.
*
* Permission to use, copy, modify, and distribute this software and its
* documentation under the terms of the GNU General Public License is hereby
* granted. No representations are made about the suitability of this software
* for any purpose. It is provided "as is" without express or implied warranty.
* See the GNU General Public License for more details.
*
* All output generated with Doxygen is not covered by this license.
*
*/
#ifndef MEMBERDEF_H
#define MEMBERDEF_H
#include "qtbc.h"
#include <qlist.h>
#include <qdict.h>
#include "entry.h"
#include "example.h"
#include "config.h"
#include "outputlist.h"
#include "definition.h"
#include "config.h"
class FileDef;
class MemberList;
class NamespaceDef;
class MemberDef : public Definition
{
public:
enum MemberType {
Define,
Function,
Variable,
Typedef,
Enumeration,
EnumValue,
Prototype,
Signal,
Slot,
Friend
};
MemberDef(const char *type,const char *name,const char *args,
const char *excp,Protection prot,Specifier virt,bool stat,
bool related,MemberType t,const ArgumentList *tal,
const ArgumentList *al);
~MemberDef();
QCString getOutputFileBase() const;
const char *declaration() const { return decl; }
const char *definition() const { return def; }
const char *typeString() const { return type; }
const char *argsString() const { return args; }
const char *excpString() const { return exception; }
const char *anchor() const { return ref; }
QCString bodyCode() const { return body; }
ClassDef *memberClass() { return classDef; }
Protection protection() const { return prot; }
Specifier virtualness() const { return virt; }
MemberType memberType() const { return mtype; }
void setMemberType(MemberType t) { mtype=t; }
void setDefinition(const char *d) { def=d; }
void setDefFile(const char *f) { defFile=f; }
void setDefLine(int l) { defLine=l; }
void setFileDef(FileDef *fd) { fileDef=fd; }
void setFileDec(FileDef *fd) { fileDec=fd; }
void setAnchor(const char *a) { ref=a; }
void setProtection(Protection p) { prot=p; }
void setBody(const QCString &b) { body=b; }
FileDef *getFileDef() { return fileDef; }
FileDef *getFileDec() { return fileDec; }
void setMemberClass(ClassDef *cd) { classDef=cd; }
bool isRelated() const { return related; }
bool isStatic() const { return stat; }
bool hasDocumentation() // overrides hasDocumentation in definition.h
{ return !documentation().isNull() ||
!briefDescription().isNull() ||
!body.isEmpty() ||
Config::extractAllFlag;
}
bool detailsAreVisible() const
{ return !documentation().isEmpty() || !body.isEmpty() ||
(mtype==Enumeration && docEnumValues) ||
(mtype==EnumValue && !briefDescription().isEmpty()) ||
(!briefDescription().isEmpty() &&
!Config::briefMemDescFlag && Config::repeatBriefFlag);
}
// relation to other members
void setReimplements(MemberDef *md) { redefines=md; }
void insertReimplementedBy(MemberDef *md);
MemberDef *reimplements() { return redefines; }
MemberList *reimplementedBy() { return redefinedBy; }
// enumeration specific members
void insertEnumField(MemberDef *md);
void setEnumScope(MemberDef *md) { enumScope=md; }
MemberDef *getEnumScope() const { return enumScope; }
void setEnumDecl(OutputList &ed) { enumDeclList=new OutputList(&ed); }
void setEnumUsed() { eUsed=TRUE; }
bool enumUsed() const { return eUsed; }
OutputList *enumDecl() const { return enumDeclList; }
MemberList *enumFieldList() { return enumFields; }
void setDocumentedEnumValues(bool value) { docEnumValues=value; }
bool hasDocumentedEnumValues() const { return docEnumValues; }
// example related members
bool addExample(const char *anchor,const char *name,const char *file);
//void writeExample(OutputList &ol);
bool hasExamples();
ExampleList *getExampleList() const { return exampleList; }
// prototype related members
const char *getDefFile() { return defFile; }
int getDefLine() { return defLine; }
void setDecFile(const char *f) { declFile=f; }
void setDecLine(int l) { defLine=l; }
// convenience members
bool isSignal() const { return mtype==Signal; }
bool isSlot() const { return mtype==Slot; }
bool isVariable() const { return mtype==Variable; }
bool isEnumerate() const { return mtype==Enumeration; }
bool isEnumValue() const { return mtype==EnumValue; }
bool isTypedef() const { return mtype==Typedef; }
bool isFunction() const { return mtype==Function; }
bool isDefine() const { return mtype==Define; }
bool isFriend() const { return mtype==Friend; }
// prototype related members
void setPrototype(bool p) { proto=p; }
bool isPrototype() const { return proto; }
// tag file related members
void setReference(const char *r) { external=r; }
bool isReference() { return !external.isNull(); }
// argument related members
ArgumentList *argumentList() const { return argList; }
void setArgumentList(ArgumentList *al)
{ if (argList) delete argList;
argList = al;
}
ArgumentList *templateArguments() const { return tArgList; }
void setScopeTemplateArguments(ArgumentList *t);
ArgumentList *scopeTemplateArguments() const { return scopeTAL; }
QCString getScopeTemplateNameString();
// namespace related members
NamespaceDef *getNamespace() { return nspace; }
void setNamespace(NamespaceDef *nd) { nspace=nd; }
private:
ClassDef *classDef; // member of or related to
FileDef *fileDef; // member of file definition
FileDef *fileDec; // member of file declaration
MemberDef *redefines; // the member that is redefined by this one
MemberDef *enumScope; // the enclosing scope, if this is an enum field
MemberList *redefinedBy; // the list of members that redefine this one
MemberDef *memDef; // member definition for this declaration
MemberDef *memDec; // member declaration for this definition
ExampleList *exampleList; // a list of all examples using this member
ExampleDict *exampleDict; // a dictionary of all examples for quick access
MemberList *enumFields; // enumeration fields
OutputList *enumDeclList; // stored piece of documentation for enumeration.
NamespaceDef *nspace; // the namespace this member is in.
QCString type; // return type
QCString args; // function arguments/variable array specifiers
QCString exception; // exceptions that can be thrown
QCString body; // function body code
QCString decl; // member declaration in class
QCString declFile; // file where the declaration was found
int declLine; // line where the declaration was found
QCString def; // member definition in code (fully qualified name)
QCString defFile; // file where the definition was found
int defLine; // line where the definition was found
QCString ref; // HTML anchor name
Specifier virt; // normal/virtual/pure virtual
Protection prot; // protection type [Public/Protected/Private]
bool related; // is this a member that is only related to a class
QCString external; // anchor of a member if extracted from a tag file
bool stat; // is it a static function?
MemberType mtype; // returns the kind of member
bool eUsed; // is the enumerate already placed in a list
bool proto; // is it a prototype;
bool docEnumValues; // is an enum with documented enum values.
ArgumentList *argList; // argument list of this member
ArgumentList *tArgList; // template argument list of function template
ArgumentList *scopeTAL; // template argument list of class template
// disable copying of member defs
MemberDef(const MemberDef &);
MemberDef &operator=(const MemberDef &);
};
#endif
|
