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
|
/*
* Modification History
*
* 2001-February-10 Jason Rohrer
* Created.
*
* 2001-September-4 Jason Rohrer
* Changed the destructor to virtual to fix a memory leak.
*
* 2001-September-9 Jason Rohrer
* Changed setArgument to be more intelligent about duplicated calls.
* Added an extractArgument() implemenation.
*/
#ifndef UNARY_OPERATION_EXPRESSION_INCLUDED
#define UNARY_OPERATION_EXPRESSION_INCLUDED
#include "Expression.h"
/**
* Abstract base for an unary operation expression object.
*
* @author Jason Rohrer
*/
class UnaryOperationExpression : public Expression {
public:
/**
* Constructs a unary operation expression.
*
* Argument is destroyed when the class is destroyed.
*
* @param inArgument the argument. Defaults to NULL.
*/
UnaryOperationExpression( Expression *inArgument = NULL );
virtual ~UnaryOperationExpression();
/**
* Sets the argument for the operation.
*
* @param inArgument the argument. Is destroyed
* when the class is destroyed, or by another
* call to setArgument.
*/
void setArgument( Expression *inArgument );
/**
* Gets the argument for the operation.
*
* @return the argument. Is destroyed
* when the class is destroyed, or by another
* call to setArgumentB. Returns NULL if the
* argument was never set.
*/
Expression *getArgument();
// implements the Expression interface
virtual long getNumArguments();
virtual Expression *getArgument( long inArgumentNumber );
virtual void setArgument( long inArgumentNumber,
Expression *inArgument );
virtual Expression *extractArgument( long inArgumentNumber );
protected:
Expression *mArgument;
};
inline UnaryOperationExpression::UnaryOperationExpression(
Expression *inArgument )
: mArgument( inArgument ) {
}
inline UnaryOperationExpression::~UnaryOperationExpression() {
if( mArgument != NULL ) {
delete mArgument;
}
}
inline void UnaryOperationExpression::setArgument( Expression *inArgument ) {
if( mArgument != NULL && inArgument != mArgument ) {
delete mArgument;
}
mArgument = inArgument;
}
inline Expression *UnaryOperationExpression::getArgument() {
return mArgument;
}
long UnaryOperationExpression::getNumArguments() {
return 1;
}
inline Expression *UnaryOperationExpression::getArgument(
long inArgumentNumber ) {
if( inArgumentNumber == 0 ) {
return getArgument();
}
else {
return NULL;
}
}
inline void UnaryOperationExpression::setArgument( long inArgumentNumber,
Expression *inArgument ) {
if( inArgumentNumber == 0 ) {
setArgument( inArgument );
return;
}
else {
return;
}
}
inline Expression *UnaryOperationExpression::extractArgument(
long inArgumentNumber ) {
Expression *returnArg = mArgument;
mArgument = NULL;
return returnArg;
}
#endif
|
