← Back to branch summary

~tapaal-ltl/verifypn/answer-for-gui

« back to all changes in this revision

Viewing changes to include/PetriEngine/PQL/Visitor.h

  • Committer: srba.jiri at gmail
  • Date: 2021-04-02 18:13:50 UTC
  • mfrom: (230.1.28 mcc2021)
  • Revision ID: srba.jiri@gmail.com-20210402181350-k71xtjut3r48l1o5
merged in lp:~tapaal-ltl/verifypn/mcc2021 adding LTL, colored fixed-point unfolding for CPN and other performance improvements

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/PetriEngine/PQL/Visitor.h
24
24
            Visitor() {}
25
25
 
26
26
            template<typename T>
27
 
            void accept(T element)
 
27
            void accept(T &&element)
28
28
            {
29
29
                _accept(element);
30
30
            }
36
36
            virtual void _accept(const OrCondition* element) = 0;
37
37
            virtual void _accept(const LessThanCondition* element) = 0;
38
38
            virtual void _accept(const LessThanOrEqualCondition* element) = 0;
39
 
            virtual void _accept(const GreaterThanCondition* element) = 0;
40
 
            virtual void _accept(const GreaterThanOrEqualCondition* element) = 0;
41
39
            virtual void _accept(const EqualCondition* element) = 0;
42
40
            virtual void _accept(const NotEqualCondition* element) = 0;
43
41
 
62
60
            virtual void _accept(const EUCondition*)
63
61
            {   assert(false); std::cerr << "No accept for EUCondition" << std::endl; exit(0);};
64
62
            virtual void _accept(const AUCondition*)
65
 
            {   assert(false); std::cerr << "No accept for AUCondition" << std::endl; exit(0);};            
66
 
            
 
63
            {   assert(false); std::cerr << "No accept for AUCondition" << std::endl; exit(0);};
 
64
            virtual void _accept(const ACondition*)
 
65
            {   assert(false); std::cerr << "No accept for ACondition" << std::endl; exit(0);};
 
66
            virtual void _accept(const ECondition*)
 
67
            {   assert(false); std::cerr << "No accept for ECondition" << std::endl; exit(0);};
 
68
            virtual void _accept(const GCondition*)
 
69
            {   assert(false); std::cerr << "No accept for GCondition" << std::endl; exit(0);};
 
70
            virtual void _accept(const FCondition*)
 
71
            {   assert(false); std::cerr << "No accept for FCondition" << std::endl; exit(0);};
 
72
            virtual void _accept(const XCondition*)
 
73
            {   assert(false); std::cerr << "No accept for XCondition" << std::endl; exit(0);};
 
74
            virtual void _accept(const UntilCondition*)
 
75
            {   assert(false); std::cerr << "No accept for UntilCondition" << std::endl; exit(0);};
 
76
 
67
77
            // shallow elements, neither of these should exist in a compiled expression
68
78
            virtual void _accept(const UnfoldedFireableCondition* element) 
69
79
            {   assert(false); std::cerr << "No accept for UnfoldedFireableCondition" << std::endl; exit(0);};
93
103
            // shallow expression, default to error
94
104
            virtual void _accept(const IdentifierExpr* element)
95
105
            {   assert(false); std::cerr << "No accept for IdentifierExpr" << std::endl; exit(0);};
96
 
        }; 
 
106
        };
 
107
 
 
108
        class ExpressionVisitor : public Visitor {
 
109
        public:
 
110
 
 
111
        private:
 
112
            void _accept(const NotCondition *element) override {
 
113
                assert(false);
 
114
                std::cerr << "No accept for NotCondition" << std::endl;
 
115
                exit(0);
 
116
            };
 
117
 
 
118
            void _accept(const AndCondition *element) override {
 
119
                assert(false);
 
120
                std::cerr << "No accept for AndCondition" << std::endl;
 
121
                exit(0);
 
122
            };
 
123
 
 
124
            void _accept(const OrCondition *element) override {
 
125
                assert(false);
 
126
                std::cerr << "No accept for OrCondition" << std::endl;
 
127
                exit(0);
 
128
            };
 
129
 
 
130
            void _accept(const LessThanCondition *element) override {
 
131
                assert(false);
 
132
                std::cerr << "No accept for LessThanCondition" << std::endl;
 
133
                exit(0);
 
134
            };
 
135
 
 
136
            void _accept(const LessThanOrEqualCondition *element) override {
 
137
                assert(false);
 
138
                std::cerr << "No accept for LessThanOrEqualCondition" << std::endl;
 
139
                exit(0);
 
140
            };
 
141
 
 
142
            void _accept(const EqualCondition *element) override {
 
143
                assert(false);
 
144
                std::cerr << "No accept for EqualCondition" << std::endl;
 
145
                exit(0);
 
146
            };
 
147
 
 
148
            void _accept(const NotEqualCondition *element) override {
 
149
                assert(false);
 
150
                std::cerr << "No accept for NotEqualCondition" << std::endl;
 
151
                exit(0);
 
152
            };
 
153
 
 
154
            void _accept(const DeadlockCondition *element) override {
 
155
                assert(false);
 
156
                std::cerr << "No accept for DeadlockCondition" << std::endl;
 
157
                exit(0);
 
158
            };
 
159
 
 
160
            void _accept(const CompareConjunction *element) override {
 
161
                assert(false);
 
162
                std::cerr << "No accept for CompareConjunction" << std::endl;
 
163
                exit(0);
 
164
            };
 
165
 
 
166
            void _accept(const UnfoldedUpperBoundsCondition *element) override {
 
167
                assert(false);
 
168
                std::cerr << "No accept for UnfoldedUpperBoundsCondition" << std::endl;
 
169
                exit(0);
 
170
            };
 
171
        };
 
172
 
97
173
    }
98
174
}
99
175