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
|
/******************************************************************************
*
* Copyright (C) 1997-2015 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.
*
* Documents produced by Doxygen are derivative works derived from the
* input used in their production; they are not affected by this license.
*
*/
#ifndef ARGUMENTS_H
#define ARGUMENTS_H
#include <qlist.h>
#include <qcstring.h>
class StorageIntf;
/*! \brief This class contains the information about the argument of a
* function or template
*
*/
struct Argument
{
/*! Construct a new argument. */
Argument() {}
/*! Copy an argument (does a deep copy of all strings). */
Argument(const Argument &a)
{
attrib=a.attrib;
type=a.type;
name=a.name;
array=a.array;
defval=a.defval;
docs=a.docs;
typeConstraint=a.typeConstraint;
}
/*! Assignment of an argument (does a deep copy of all strings). */
Argument &operator=(const Argument &a)
{
if (this!=&a)
{
attrib=a.attrib;
type=a.type;
name=a.name;
array=a.array;
defval=a.defval;
docs=a.docs;
typeConstraint=a.typeConstraint;
}
return *this;
}
/*! return TRUE if this argument is documentation and the argument has a
* non empty name.
*/
bool hasDocumentation() const
{
return !name.isEmpty() && !docs.isEmpty();
}
QCString attrib; /*!< Argument's attribute (IDL only) */
QCString type; /*!< Argument's type */
QCString canType; /*!< Cached value of canonical type (after type resolution). Empty initially. */
QCString name; /*!< Argument's name (may be empty) */
QCString array; /*!< Argument's array specifier (may be empty) */
QCString defval; /*!< Argument's default value (may be empty) */
QCString docs; /*!< Argument's documentation (may be empty) */
QCString typeConstraint; /*!< Used for Java generics: \<T extends C\> */
};
enum RefQualifierType
{
RefQualifierNone,
RefQualifierLValue,
RefQualifierRValue
};
/*! \brief This class represents an function or template argument list.
*
* This class also stores some information about member that is typically
* put after the argument list, such as whether the member is const,
* volatile or pure virtual.
*/
class ArgumentList : public QList<Argument>
{
public:
/*! Creates an empty argument list */
ArgumentList() : QList<Argument>(),
constSpecifier(FALSE),
volatileSpecifier(FALSE),
pureSpecifier(FALSE),
isDeleted(FALSE),
refQualifier(RefQualifierNone)
{ setAutoDelete(TRUE); }
/*! Destroys the argument list */
~ArgumentList() {}
/*! Makes a deep copy of this object */
ArgumentList *deepCopy() const;
/*! Does any argument of this list have documentation? */
bool hasDocumentation() const;
/*! Does the member modify the state of the class? default: FALSE. */
bool constSpecifier;
/*! Is the member volatile? default: FALSE. */
bool volatileSpecifier;
/*! Is this a pure virtual member? default: FALSE */
bool pureSpecifier;
/*! C++11 style Trailing return type? */
QCString trailingReturnType;
/*! method with =delete */
bool isDeleted;
/*! C++11 ref qualifier */
RefQualifierType refQualifier;
};
typedef QListIterator<Argument> ArgumentListIterator;
#endif
|
