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
|
/******************************************************************************
*
* $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 <qstring.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();
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; }
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; }
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 detailsAreVisible() const
{ return !documentation().isEmpty() ||
(mtype==Enumeration && docEnumValues) ||
(mtype==EnumValue && !briefDescription().isEmpty()) ||
(!briefDescription().isEmpty() &&
!briefMemDescFlag && 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();
// 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; }
ArgumentList *templateArguments() const { return tArgList; }
// 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.
QString type; // return type
QString args; // function arguments/variable array specifiers
QString exception; // exceptions that can be thrown
QString decl; // member declaration in class
QString declFile; // file where the declaration was found
int declLine; // line where the declaration was found
QString def; // member definition in code (fully qualified name)
QString defFile; // file where the definition was found
int defLine; // line where the definition was found
QString 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
QString 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
// disable copying of member defs
MemberDef(const MemberDef &);
MemberDef &operator=(const MemberDef &);
};
#endif
|
