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
|
// Empty set expression -*- c++ -*-
#ifndef EMPTYSET_H_
# define EMPTYSET_H_
# ifdef __GNUC__
# pragma interface
# endif // __GNUC__
# include "Expression.h"
/** @file EmptySet.h
* Literal for empty multi-sets
*/
/* Copyright 1999-2002 Marko Mkel (msmakela@tcs.hut.fi).
This file is part of MARIA, a reachability analyzer and model checker
for high-level Petri nets.
MARIA is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
MARIA is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
The GNU General Public License is often shipped with GNU software, and
is generally kept in a file called COPYING or LICENSE. If you do not
have a copy of the license, write to the Free Software Foundation,
59 Temple Place, Suite 330, Boston, MA 02111 USA. */
/** Empty multi-set expression */
class EmptySet : public Expression
{
public:
/** Constructor */
EmptySet () {}
private:
/** Copy constructor */
EmptySet (const class EmptySet& old);
/** Assignment operator */
class EmptySet& operator= (const class EmptySet& old);
protected:
/** Destructor */
~EmptySet () {}
public:
/** Determine the type of the expression */
enum Expression::Kind getKind () const { return eEmptySet; }
/**
* Determine whether this is a basic expression containing
* no temporal logic or set operations
* @return true if this is a basic expression
*/
bool isBasic () const { return false; }
/** Determine whether this is a temporal logic expression */
bool isTemporal () const { return false; }
/**
* Determine whether this is a multiset-valued expression
* @return true if this is a multiset-valued expression
*/
bool isSet () const { return true; }
/** Equality comparison operator */
bool operator== (const class EmptySet&) const { return true; }
/** Ordering comparison operator */
bool operator< (const class EmptySet&) const { return false; }
/** Evaluate the multiset expression
* @param valuation variable substitutions and the global marking
* @return the filtered marking
*/
class PlaceMarking* meval (const class Valuation& valuation) const;
/** Partially evaluate the expression using a valuation
* @return grounded expression, or NULL in case of error
*/
class Expression* ground (const class Valuation&,
class Transition*, bool) { return copy (); }
/** Substitute some variables in the expression with expressions
* @return substituted expression
*/
class Expression* substitute (class Substitution&) { return copy (); }
/** Determine whether the expression depends on a set of variables
* @param vars the set of variables
* @param complement flag: treat the set as its complement
*/
bool depends (const class VariableSet& vars,
bool complement) const;
/** Perform an operation on all subexpressions of the expression
* @param operation operation to be performed (return false on failure)
* @param data parameters to be passed to the operation
* @return true if all operations succeeded
*/
bool forExpressions (bool (*operation)
(const class Expression&,void*),
void* data) const;
# ifdef EXPR_COMPILE
/** Generate C code for evaluating the expression */
void compile (class CExpression&,
unsigned,
const char*,
const class VariableSet*) const {
assert (false);
}
# endif // EXPR_COMPILE
/** Display the expression
* @param printer the printer object
*/
void display (const class Printer& printer) const;
};
#endif // EMPTYSET_H_
|
