← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/dk/aau/cs/model/tapn/LocalTimedMarking.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/model/tapn/LocalTimedMarking.java
 
1
package dk.aau.cs.model.tapn;
 
2
 
 
3
import java.math.BigDecimal;
 
4
import java.util.ArrayList;
 
5
import java.util.HashMap;
 
6
import java.util.List;
 
7
import java.util.Map.Entry;
 
8
 
 
9
import dk.aau.cs.model.tapn.simulation.FiringMode;
 
10
import dk.aau.cs.util.Require;
 
11
 
 
12
// This class must remain immutable wrt. delays and transition firings!
 
13
public class LocalTimedMarking implements TimedMarking { // TODO: Consider removing the interface here?
 
14
        private HashMap<TimedPlace, List<TimedToken>> placesToTokensMap;
 
15
        private NetworkMarking parent;
 
16
 
 
17
        public LocalTimedMarking() {
 
18
                placesToTokensMap = new HashMap<TimedPlace, List<TimedToken>>();
 
19
        }
 
20
 
 
21
        public void setNetworkMarking(NetworkMarking marking){
 
22
                this.parent = marking;
 
23
        }
 
24
 
 
25
        public void add(TimedToken token) {
 
26
                if(token.place().isShared()) {
 
27
                        parent.add(token);
 
28
                } else {
 
29
                        if (!placesToTokensMap.containsKey(token.place())) {
 
30
                                placesToTokensMap.put(token.place(), new ArrayList<TimedToken>());
 
31
                        }
 
32
 
 
33
                        List<TimedToken> tokens = placesToTokensMap.get(token.place());
 
34
                        tokens.add(token);
 
35
                }
 
36
        }
 
37
 
 
38
        private void add(List<TimedToken> producedTokens) {
 
39
                for (TimedToken token : producedTokens) {
 
40
                        add(token);
 
41
                }
 
42
        }
 
43
 
 
44
        public void remove(TimedToken token) {
 
45
                if(token.place().isShared()) {
 
46
                        parent.remove(token);
 
47
                } else if (placesToTokensMap.containsKey(token.place())) {
 
48
                        List<TimedToken> tokens = placesToTokensMap.get(token.place());
 
49
                        tokens.remove(token);
 
50
                }
 
51
        }
 
52
 
 
53
 
 
54
        private void remove(List<TimedToken> tokensToConsume) {
 
55
                for (TimedToken token : tokensToConsume) {
 
56
                        remove(token);
 
57
                }
 
58
        }
 
59
 
 
60
        public void removePlaceFromMarking(TimedPlace place) {
 
61
                if(place.isShared()){
 
62
                        parent.removePlaceFromMarking(place);
 
63
                }else{
 
64
                        if(placesToTokensMap.containsKey(place)){
 
65
                                placesToTokensMap.remove(place);
 
66
                        }
 
67
                }
 
68
        }
 
69
 
 
70
        private List<TimedToken> getTokensFor(LocalTimedPlace place) {
 
71
                if (!placesToTokensMap.containsKey(place))
 
72
                        return new ArrayList<TimedToken>();
 
73
                return placesToTokensMap.get(place);
 
74
        }
 
75
 
 
76
        public List<TimedToken> getTokensFor(TimedPlace place){
 
77
                if(place.isShared()){
 
78
                        return parent.getTokensFor(place);
 
79
                }else{
 
80
                        return getTokensFor((LocalTimedPlace)place);
 
81
                }
 
82
        }
 
83
 
 
84
        public boolean isDelayPossible(BigDecimal delay) {
 
85
                Require.that(delay.compareTo(BigDecimal.ZERO) >= 0, "cannot delay with negative numbers");
 
86
                for (Entry<TimedPlace, List<TimedToken>> entry : placesToTokensMap.entrySet()) {
 
87
                        for (TimedToken token : entry.getValue()) {
 
88
                                TimeInvariant invariant = token.place().invariant();
 
89
                                if (!invariant.isSatisfied(token.age().add(delay))) {
 
90
                                        return false;
 
91
                                }
 
92
                        }
 
93
                }
 
94
                return true;
 
95
        }
 
96
 
 
97
        public LocalTimedMarking clone() {
 
98
                return delay(BigDecimal.ZERO);
 
99
        }
 
100
 
 
101
        public LocalTimedMarking delay(BigDecimal amount) {
 
102
                Require.that(amount.compareTo(BigDecimal.ZERO) >= 0, "cannot delay with negative numbers");
 
103
                Require.that(isDelayPossible(amount), "The specified delay is not possible due to an invariant.");
 
104
 
 
105
                LocalTimedMarking clone = new LocalTimedMarking();
 
106
                for (Entry<TimedPlace, List<TimedToken>> entry : placesToTokensMap.entrySet()) {
 
107
                        ArrayList<TimedToken> newTokens = new ArrayList<TimedToken>(entry.getValue().size());
 
108
                        for (TimedToken token : entry.getValue()) {
 
109
                                newTokens.add(token.delay(amount));
 
110
                        }
 
111
                        clone.placesToTokensMap.put(entry.getKey(), newTokens);
 
112
                }
 
113
                
 
114
                clone.parent = parent;
 
115
                return clone;
 
116
        }
 
117
 
 
118
        public LocalTimedMarking fireTransition(TimedTransition transition, List<TimedToken> tokensToConsume) {
 
119
                Require.that(transition != null, "transition must not be null");
 
120
                Require.that(transition.isEnabledBy(tokensToConsume), "Tokens do not enable transition");
 
121
 
 
122
                LocalTimedMarking clone = clone();
 
123
 
 
124
                List<TimedToken> producedTokens = transition.calculateProducedTokensFrom(tokensToConsume);
 
125
 
 
126
                clone.remove(tokensToConsume);
 
127
                clone.add(producedTokens);
 
128
 
 
129
                return clone;
 
130
        }
 
131
 
 
132
        public LocalTimedMarking fireTransition(TimedTransition transition, FiringMode firingMode) {
 
133
                Require.that(transition != null, "transition must not be null");
 
134
                Require.that(transition.isEnabled(), "Transition must be enabled");
 
135
 
 
136
                List<TimedToken> tokensToConsume = transition.calculateConsumedTokens(this, firingMode);
 
137
 
 
138
                return fireTransition(transition, tokensToConsume);
 
139
        }
 
140
 
 
141
        public int size() {
 
142
                int size = 0;
 
143
                for (List<TimedToken> tokens : placesToTokensMap.values()) {
 
144
                        size += tokens.size();
 
145
                }
 
146
                return size;
 
147
        }
 
148
        
 
149
        
 
150
}