← Back to branch summary

~tapaal-contributor/tapaal/add-java-info-1890600

« back to all changes in this revision

Viewing changes to src/dk/aau/cs/verification/VerifyTAPN/VerifyPNOutputParser.java

merged in lp:~yrke/tapaal/removeSpecialBatchLoading removing special loading of nets in batch processing

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dk/aau/cs/verification/VerifyTAPN/VerifyPNOutputParser.java
92
92
                                } else {
93
93
                                        matcher = discoveredPattern.matcher(line);
94
94
                                        if(matcher.find()){
95
 
                                                discovered = Integer.valueOf(matcher.group(1));
 
95
                                                discovered = Integer.parseInt(matcher.group(1));
96
96
                                        }
97
97
                                        
98
98
                                        matcher = exploredPattern.matcher(line);
99
99
                                        if(matcher.find()){
100
 
                                                explored = Integer.valueOf(matcher.group(1));
 
100
                                                explored = Integer.parseInt(matcher.group(1));
101
101
                                        }
102
102
                                        
103
103
                                        matcher = maxUsedTokensPattern.matcher(line);
104
104
                                        if(matcher.find()){
105
 
                                                maxUsedTokens = Integer.valueOf(matcher.group(1));
 
105
                                                maxUsedTokens = Integer.parseInt(matcher.group(1));
106
106
                                                String operator = matcher.group(1) == null ? "" : matcher.group(1);
107
107
                                                if(operator.equals(">")) maxUsedTokens += 1; // Indicate non-k-boundedness by encoding that an extra token was used.
108
108
                                        }
114
114
                                        
115
115
                                        matcher = removedTransitionsPattern.matcher(line);
116
116
                                        if(matcher.find()){
117
 
                                                removedTransitions = Integer.valueOf(matcher.group(1));
 
117
                                                removedTransitions = Integer.parseInt(matcher.group(1));
118
118
                                        }
119
119
                                        
120
120
                                        matcher = removedPlacesPattern.matcher(line);
121
121
                                        if(matcher.find()){
122
 
                                                removedPlaces = Integer.valueOf(matcher.group(1));
 
122
                                                removedPlaces = Integer.parseInt(matcher.group(1));
123
123
                                        }
124
124
                                        
125
125
                                        matcher = ruleAApplicationPattern.matcher(line);
126
126
                                        if(matcher.find()){
127
 
                                                ruleA = Integer.valueOf(matcher.group(1));
 
127
                                                ruleA = Integer.parseInt(matcher.group(1));
128
128
                                        }
129
129
                                        
130
130
                                        matcher = ruleBApplicationPattern.matcher(line);
131
131
                                        if(matcher.find()){
132
 
                                                ruleB = Integer.valueOf(matcher.group(1));
 
132
                                                ruleB = Integer.parseInt(matcher.group(1));
133
133
                                        }
134
134
                                        
135
135
                                        matcher = ruleCApplicationPattern.matcher(line);
136
136
                                        if(matcher.find()){
137
 
                                                ruleC = Integer.valueOf(matcher.group(1));
 
137
                                                ruleC = Integer.parseInt(matcher.group(1));
138
138
                                        }
139
139
                                        
140
140
                                        matcher = ruleDApplicationPattern.matcher(line);
141
141
                                        if(matcher.find()){
142
 
                                                ruleD = Integer.valueOf(matcher.group(1));
 
142
                                                ruleD = Integer.parseInt(matcher.group(1));
143
143
                                        }
144
144
                                        
145
145
                                        matcher = ruleEApplicationPattern.matcher(line);
146
146
                                        if(matcher.find()){
147
 
                                                ruleE = Integer.valueOf(matcher.group(1));
 
147
                                                ruleE = Integer.parseInt(matcher.group(1));
148
148
                                        }
149
149
                                        
150
150
                                        matcher = ruleFApplicationPattern.matcher(line);
151
151
                                        if(matcher.find()){
152
 
                                                ruleF = Integer.valueOf(matcher.group(1));
 
152
                                                ruleF = Integer.parseInt(matcher.group(1));
153
153
                                        }
154
154
                                        
155
155
                                        matcher = ruleGApplicationPattern.matcher(line);
156
156
                                        if(matcher.find()){
157
 
                                                ruleG = Integer.valueOf(matcher.group(1));
 
157
                                                ruleG = Integer.parseInt(matcher.group(1));
158
158
                                        }
159
159
                                        
160
160
                                        matcher = ruleHApplicationPattern.matcher(line);
161
161
                                        if(matcher.find()){
162
 
                                                ruleH = Integer.valueOf(matcher.group(1));
 
162
                                                ruleH = Integer.parseInt(matcher.group(1));
163
163
                                        }
164
164
                                        
165
165
                                        matcher = ruleIApplicationPattern.matcher(line);
166
166
                                        if(matcher.find()){
167
 
                                                ruleI = Integer.valueOf(matcher.group(1));
 
167
                                                ruleI = Integer.parseInt(matcher.group(1));
168
168
                                        }
169
169
                                }
170
170
                        }