← Back to branch summary

~tapaal-contributor/tapaal/disappearing-tokens-1940098

« back to all changes in this revision

Viewing changes to src/dk/aau/cs/verification/UPPAAL/VerifytaTraceParser.java

  • Committer: Kenneth Yrke Jørgensen
  • Date: 2011-04-12 09:50:16 UTC
  • mfrom: (329.1.188 tapaal-1.5)
  • Revision ID: mail@yrke.dk-20110412095016-e4hqdgab5596ja09
Merged with branch addning support for new 1.5 features

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/dk/aau/cs/verification/UPPAAL/VerifytaTraceParser.java
3
3
import java.io.BufferedReader;
4
4
import java.io.IOException;
5
5
 
6
 
import dk.aau.cs.TA.trace.SymbolicState;
7
 
import dk.aau.cs.TA.trace.TimeDelayFiringAction;
8
 
import dk.aau.cs.TA.trace.TransitionFiring;
9
 
import dk.aau.cs.TA.trace.UppaalTrace;
 
6
import dk.aau.cs.model.NTA.trace.SymbolicState;
 
7
import dk.aau.cs.model.NTA.trace.TimeDelayFiringAction;
 
8
import dk.aau.cs.model.NTA.trace.TransitionFiring;
 
9
import dk.aau.cs.model.NTA.trace.UppaalTrace;
10
10
 
11
11
public class VerifytaTraceParser {
12
 
        public UppaalTrace parseTrace(BufferedReader reader){
 
12
        public UppaalTrace parseTrace(BufferedReader reader) {
13
13
                UppaalTrace trace = new UppaalTrace();
14
 
                try {                   
 
14
                try {
15
15
                        String line;
16
16
                        SymbolicState previousState = null;
17
17
                        TransitionFiring previousTransitionFiring = null;
18
18
                        boolean nextIsState = false;
19
 
                        while(reader.ready()){
 
19
                        while (reader.ready()) {
20
20
                                StringBuffer buffer = new StringBuffer();
21
 
                                while((line = reader.readLine()) != null && !line.isEmpty()){
 
21
                                while ((line = reader.readLine()) != null && !line.isEmpty()) {
22
22
                                        buffer.append(line);
23
23
                                        buffer.append("\n");
24
24
                                }
25
 
                                
 
25
 
26
26
                                String element = buffer.toString();
27
 
                                
28
 
                                if(line == null && element.isEmpty()) break; // we are done parsing trace, exit outer loop
29
 
                                
30
 
                                if(nextIsState){ // untimed trace
 
27
 
 
28
                                if (line == null && element.isEmpty())
 
29
                                        break; // we are done parsing trace, exit outer loop
 
30
 
 
31
                                if (nextIsState) { // untimed trace
31
32
                                        SymbolicState state = SymbolicState.parse("State:\n" + element);
32
33
                                        trace.addState(state);
33
34
                                        previousState = state;
34
 
                                        if(previousTransitionFiring != null){
 
35
                                        if (previousTransitionFiring != null) {
35
36
                                                previousTransitionFiring.setTargetState(state);
36
37
                                                previousTransitionFiring = null;
37
 
                                        }       
 
38
                                        }
38
39
                                        nextIsState = false;
39
 
                                }else if(element.contains("State\n")){ // untimed trace
 
40
                                } else if (element.contains("State\n")) { // untimed trace
40
41
                                        nextIsState = true;
41
 
                                }else if(element.contains("State:\n")){ // timed trace
 
42
                                } else if (element.contains("State:\n")) { // timed trace
42
43
                                        SymbolicState state = SymbolicState.parse(element);
43
44
                                        trace.addState(state);
44
45
                                        previousState = state;
45
 
                                        if(previousTransitionFiring != null){
 
46
                                        if (previousTransitionFiring != null) {
46
47
                                                previousTransitionFiring.setTargetState(state);
47
48
                                                previousTransitionFiring = null;
48
 
                                        }                                       
49
 
                                }else if(element.contains("Delay:")){
50
 
                                        TimeDelayFiringAction delay = TimeDelayFiringAction.parse(previousState, element);
 
49
                                        }
 
50
                                } else if (element.contains("Delay:")) {
 
51
                                        TimeDelayFiringAction delay = TimeDelayFiringAction.parse(
 
52
                                                        previousState, element);
51
53
                                        trace.addFiringAction(delay);
52
 
                                }else if(element.contains("Transitions:")){
53
 
                                        TransitionFiring transition = TransitionFiring.parse(previousState, element);
 
54
                                } else if (element.contains("Transitions:")) {
 
55
                                        TransitionFiring transition = TransitionFiring.parse(
 
56
                                                        previousState, element);
54
57
                                        trace.addFiringAction(transition);
55
58
                                        previousTransitionFiring = transition;
56
59
                                }
58
61
                } catch (IOException e) {
59
62
                        return null;
60
63
                }
61
 
                
 
64
 
62
65
                return trace.isEmpty() ? null : trace;
63
66
        }
64
67
}