1 package cz.cuni.amis.pogamut.sposh.elements;
2
3 import cz.cuni.amis.pogamut.sposh.executor.IAction;
4 import java.util.AbstractList;
5 import java.util.ArrayList;
6 import java.util.Collections;
7 import java.util.List;
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27 public class Arguments extends AbstractList<Arguments.Argument> {
28
29 public static Arguments EMPTY = new Arguments();
30
31
32
33
34
35
36
37
38 public static abstract class Argument {
39
40 final private String argumentName;
41
42
43
44
45
46
47 protected Argument(String argumentName) {
48 this.argumentName = argumentName;
49 }
50
51
52
53
54
55
56 public abstract Object getValue();
57
58
59
60
61
62
63
64 public abstract String getParameterVariable();
65
66
67
68
69 @Deprecated
70 public String getParameterName() {
71 return argumentName;
72 }
73
74 public String getName() {
75 return argumentName;
76 }
77
78 @Override
79 public abstract String toString();
80
81 @Override
82 protected abstract Argument clone();
83
84
85
86
87
88
89
90
91 public static Argument createValueArgument(String argumentName, Object value) {
92 return new ValueArgument(argumentName, value);
93 }
94
95
96
97
98
99
100
101
102
103
104 public static Argument createVariableArgument(String argumentName, String variableName) {
105 return new VariableArgument(argumentName, variableName);
106 }
107 }
108
109
110
111
112 protected static final class VariableArgument extends Arguments.Argument {
113
114 protected final String variableName;
115
116 protected VariableArgument(int index, String variableName) {
117 super(Integer.toString(index));
118 this.variableName = variableName;
119 }
120
121
122
123
124
125
126
127
128 protected VariableArgument(String parameterName, String variableName) {
129 super(parameterName);
130 this.variableName = variableName;
131 }
132
133 @Override
134 public String getValue() {
135 throw new UnsupportedOperationException("Not yet implemented");
136 }
137
138 @Override
139 public String getParameterVariable() {
140 return variableName;
141 }
142
143 @Override
144 public String toString() {
145 if (getParameterName().startsWith("$")) {
146 return getParameterName() + "=" + variableName;
147 }
148 return variableName;
149 }
150
151 @Override
152 protected VariableArgument clone() {
153 return new VariableArgument(getParameterName(), variableName);
154 }
155 }
156
157
158
159
160
161 protected static final class ValueArgument extends Arguments.Argument {
162
163 private final Object value;
164
165
166
167
168
169
170
171
172
173
174 protected ValueArgument(int sequenceNumber, Object value) {
175 super(Integer.toString(sequenceNumber));
176 this.value = value;
177 }
178
179 protected ValueArgument(String parameterName, Object value) {
180 super(parameterName);
181 this.value = value;
182 }
183
184 @Override
185 public Object getValue() {
186 return value;
187 }
188
189 @Override
190 public String getParameterVariable() {
191 return null;
192 }
193
194 @Override
195 public String toString() {
196 if (getParameterName().startsWith("$")) {
197 return getParameterName() + "=" + Result.toLap(value);
198 }
199 return Result.toLap(value);
200 }
201
202 @Override
203 protected ValueArgument clone() {
204 return new ValueArgument(getParameterName(), value);
205 }
206 }
207 private List<Arguments.Argument> parameters = new ArrayList<Argument>();
208
209
210
211
212
213 public Arguments() {
214 }
215
216
217
218
219
220
221
222 protected Arguments(Arguments parameters) {
223 for (int i = 0; i < parameters.size(); ++i) {
224 Argument parameter = parameters.get(i);
225 Argument clone = parameter.clone();
226 this.parameters.add(clone);
227 }
228 }
229
230
231
232
233
234 public String[] getAllNames() {
235 List<String> names = new ArrayList<String>(this.size());
236 for (Arguments.Argument arg : this.parameters) {
237 names.add(arg.getName());
238 }
239 Collections.sort(names);
240 return names.toArray(new String[names.size()]);
241 }
242
243
244
245
246
247 @Override
248 public synchronized Arguments.Argument get(int index) {
249 return parameters.get(index);
250 }
251
252
253
254
255 @Override
256 public synchronized int size() {
257 return parameters.size();
258 }
259
260
261
262
263
264
265 @Override
266 public void add(int index, Argument element) {
267 parameters.add(index, element);
268 }
269
270
271
272
273
274
275
276 public synchronized boolean addFormal(Arguments.Argument newArgument, FormalParameters formalParams) {
277
278 for (int i = 0; i < parameters.size(); ++i) {
279 String parameterName = parameters.get(i).getParameterName();
280
281 if (parameterName != null && parameterName.equals(newArgument.getParameterName())) {
282 throw new IllegalArgumentException("Named parameter \"" + newArgument.getParameterName() + "\" has already been defined.");
283 }
284 }
285 return parameters.add(newArgument);
286 }
287
288
289
290
291
292
293
294
295 @Override
296 public String toString() {
297 StringBuilder sb = new StringBuilder();
298 for (int argumentIndex = 0; argumentIndex < parameters.size(); ++argumentIndex) {
299 if (argumentIndex != 0) {
300 sb.append(',');
301 }
302 Argument argument = parameters.get(argumentIndex);
303 sb.append(argument.toString());
304 }
305 return sb.toString();
306 }
307 }