blob: 59e90a5185b31b87b3636a547555a0ddfe6def04 (
plain)
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
|
#ifndef EXPRESSIONS_H_
#define EXPRESSIONS_H_
#include <string>
#include <map>
#include <iostream>
using namespace std;
typedef enum {
PREDICATE,
NOT,
AND,
OR
} ExprType;
class Expression {
public:
virtual bool evaluate( ) = 0;
virtual void print( ostream& o ) = 0;
virtual ExprType type( ) = 0;
};
class NotExpression : public Expression {
private:
Expression *expr;
public:
NotExpression( Expression *_expr )
: expr( _expr ) {
}
virtual bool evaluate( ) {
return !expr->evaluate( );
}
virtual void print( ostream& o ) {
bool is_parent = ( expr->type( ) == AND || expr->type( ) == OR );
if( is_parent ) o << "(";
o << "NOT ";
expr->print( o );
if( is_parent ) o << ")";
}
virtual ExprType type( ) {
return NOT;
}
};
class AndExpression : public Expression {
private:
Expression *expr;
Expression *right;
public:
AndExpression( Expression *_expr, Expression *_right ) :
expr( _expr ), right( _right ) {
}
virtual bool evaluate( ) {
return expr->evaluate( ) && right->evaluate( );
}
virtual void print( ostream& o ) {
bool is_parent = ( expr->type( ) == OR );
if( is_parent ) o << "(";
expr->print( o );
if( is_parent ) o << ")";
o << " AND ";
is_parent = ( expr->type( ) == OR );
if( is_parent ) o << "(";
right->print( o );
if( is_parent ) o << ")";
}
virtual ExprType type( ) {
return AND;
}
};
class OrExpression : public Expression {
private:
Expression *expr;
Expression *right;
public:
OrExpression( Expression *_expr, Expression *_right ) :
expr( _expr ), right( _right ) {
}
virtual bool evaluate( ) {
return expr->evaluate( ) || right->evaluate( );
}
virtual void print( ostream& o ) {
expr->print( o );
o << " OR ";
right->print( o );
}
virtual ExprType type( ) {
return OR;
}
};
class Predicate : public Expression {
private:
string ident;
public:
Predicate( const string _ident )
: ident( _ident ) {
}
virtual bool evaluate( ) {
return false;
}
virtual void print( ostream& o ) {
o << ident;
}
virtual ExprType type( ) {
return PREDICATE;
}
};
class Expressions : public Expression {
private:
typedef map<string,bool> valueMap;
valueMap values;
public:
Expressions( Expression *expr ) {
}
void setValue( const string ident, const bool value ) {
values[ident] = value;
}
virtual bool evaluate( ) {
}
};
#endif
|
