← 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/SharedPlace.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/SharedPlace.java
 
1
package dk.aau.cs.model.tapn;
 
2
 
 
3
import java.util.ArrayList;
 
4
import java.util.List;
 
5
import java.util.regex.Pattern;
 
6
 
 
7
import dk.aau.cs.model.tapn.event.TimedPlaceEvent;
 
8
import dk.aau.cs.model.tapn.event.TimedPlaceListener;
 
9
import dk.aau.cs.util.Require;
 
10
 
 
11
public class SharedPlace implements TimedPlace{
 
12
        private static final Pattern namePattern = Pattern.compile("^[a-zA-Z_][a-zA-Z0-9_]*$");
 
13
        
 
14
        private String name;
 
15
        private TimeInvariant invariant;
 
16
        
 
17
        private TimedArcPetriNetNetwork network;
 
18
        private TimedMarking currentMarking;
 
19
        
 
20
        private List<TimedPlaceListener> listeners = new ArrayList<TimedPlaceListener>();
 
21
 
 
22
        public SharedPlace(String name){
 
23
                this(name, TimeInvariant.LESS_THAN_INFINITY);
 
24
        }
 
25
        
 
26
        public SharedPlace(String name, TimeInvariant invariant){
 
27
                setName(name);
 
28
                setInvariant(invariant);
 
29
        }
 
30
        
 
31
        public String name() {
 
32
                return name;
 
33
        }
 
34
        
 
35
        public void setName(String newName) {
 
36
                Require.that(newName != null && !newName.isEmpty(), "A timed transition must have a name");
 
37
                Require.that(isValid(newName), "The specified name must conform to the pattern [a-zA-Z_][a-zA-Z0-9_]*");
 
38
                this.name = newName;
 
39
                fireNameChanged();
 
40
        }
 
41
        
 
42
        private boolean isValid(String newName) {
 
43
                return namePattern.matcher(newName).matches();
 
44
        }
 
45
 
 
46
        public TimeInvariant invariant(){
 
47
                return invariant;
 
48
        }
 
49
        
 
50
        public void setInvariant(TimeInvariant invariant) {
 
51
                Require.that(invariant != null, "invariant must not be null");
 
52
                this.invariant = invariant;
 
53
                fireInvariantChanged();
 
54
        }
 
55
 
 
56
        public void setNetwork(TimedArcPetriNetNetwork network) {
 
57
                this.network = network;         
 
58
        }
 
59
        
 
60
        public TimedArcPetriNetNetwork network(){
 
61
                return network;
 
62
        }
 
63
        
 
64
        public void addTimedPlaceListener(TimedPlaceListener listener) {
 
65
                Require.that(listener != null, "Listener cannot be null");
 
66
                listeners.add(listener);
 
67
        }
 
68
 
 
69
        public void removeTimedPlaceListener(TimedPlaceListener listener) {
 
70
                Require.that(listener != null, "Listener cannot be null");
 
71
                listeners.remove(listener);
 
72
        }
 
73
 
 
74
        public TimedPlace copy() {
 
75
                return this; // TODO: there should only be one of each shared place
 
76
        }
 
77
 
 
78
        public boolean isShared() {
 
79
                return true;
 
80
        }
 
81
 
 
82
        public void setCurrentMarking(TimedMarking marking) {
 
83
                Require.that(marking != null, "marking cannot be null");
 
84
                currentMarking = marking;
 
85
                fireMarkingChanged();
 
86
        }
 
87
        
 
88
        public void addToken(TimedToken timedToken) {
 
89
                Require.that(timedToken != null, "timedToken cannot be null");
 
90
                Require.that(timedToken.place().equals(this), "token is located in a different place");
 
91
                
 
92
                currentMarking.add(timedToken);
 
93
                fireMarkingChanged();
 
94
        }
 
95
        
 
96
        public void addTokens(Iterable<TimedToken> tokens) {
 
97
                Require.that(tokens != null, "tokens cannot be null"); // TODO: maybe check that tokens are in this place?
 
98
                
 
99
                for(TimedToken token : tokens){
 
100
                        currentMarking.add(token); // avoid firing marking changed on every add
 
101
                }
 
102
                fireMarkingChanged();
 
103
        }
 
104
 
 
105
        public void removeToken(TimedToken timedToken) {
 
106
                Require.that(timedToken != null, "timedToken cannot be null");
 
107
                currentMarking.remove(timedToken);
 
108
                fireMarkingChanged();
 
109
        }
 
110
 
 
111
        public void removeToken() {
 
112
                if (numberOfTokens() > 0) {
 
113
                        currentMarking.remove(tokens().get(0));
 
114
                        fireMarkingChanged();
 
115
                }
 
116
        }
 
117
 
 
118
        public List<TimedToken> tokens() {
 
119
                return currentMarking.getTokensFor(this);
 
120
        }       
 
121
 
 
122
        public int numberOfTokens() {
 
123
                return tokens().size();
 
124
        }
 
125
        
 
126
        private void fireMarkingChanged() {
 
127
                for(TimedPlaceListener listener : listeners){
 
128
                        listener.markingChanged(new TimedPlaceEvent(this));
 
129
                }
 
130
        }
 
131
        
 
132
        private void fireNameChanged() {
 
133
                for(TimedPlaceListener listener : listeners){
 
134
                        listener.nameChanged(new TimedPlaceEvent(this));
 
135
                }
 
136
        }
 
137
 
 
138
        private void fireInvariantChanged() {
 
139
                for(TimedPlaceListener listener : listeners){
 
140
                        listener.invariantChanged(new TimedPlaceEvent(this));
 
141
                }
 
142
        }
 
143
        
 
144
        @Override
 
145
        public String toString() {
 
146
                return name;
 
147
        }
 
148
 
 
149
        @Override
 
150
        public int hashCode() {
 
151
                final int prime = 31;
 
152
                int result = 1;
 
153
                result = prime * result + ((name == null) ? 0 : name.hashCode());
 
154
                return result;
 
155
        }
 
156
 
 
157
        @Override
 
158
        public boolean equals(Object obj) {
 
159
                if (this == obj)
 
160
                        return true;
 
161
                if (obj == null)
 
162
                        return false;
 
163
                if (!(obj instanceof SharedPlace))
 
164
                        return false;
 
165
                SharedPlace other = (SharedPlace) obj;
 
166
                if (name == null) {
 
167
                        if (other.name != null)
 
168
                                return false;
 
169
                } else if (!name.equals(other.name))
 
170
                        return false;
 
171
                return true;
 
172
        }
 
173
}