1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
|
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package org.apache.tools.ant.types.selectors;
import java.io.File;
import java.util.Enumeration;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.PropertyHelper;
/**
* This selector just holds one other selector and forwards all
* requests to it. It exists so that there is a single selector
* type that can exist outside of any targets, as an element of
* project. It overrides all of the reference stuff so that it
* works as expected. Note that this is the only selector you
* can reference.
*
* @since 1.5
*/
public class SelectSelector extends BaseSelectorContainer {
private Object ifCondition;
private Object unlessCondition;
/**
* Default constructor.
*/
public SelectSelector() {
}
/**
* @return a string describing this object
*/
public String toString() {
StringBuffer buf = new StringBuffer();
if (hasSelectors()) {
buf.append("{select");
if (ifCondition != null) {
buf.append(" if: ");
buf.append(ifCondition);
}
if (unlessCondition != null) {
buf.append(" unless: ");
buf.append(unlessCondition);
}
buf.append(" ");
buf.append(super.toString());
buf.append("}");
}
return buf.toString();
}
/**
* Performs the check for circular references and returns the
* referenced Selector.
*/
private SelectSelector getRef() {
Object o = getCheckedRef(this.getClass(), "SelectSelector");
return (SelectSelector) o;
}
/**
* Indicates whether there are any selectors here.
* @return whether any selectors are in this container
*/
public boolean hasSelectors() {
if (isReference()) {
return getRef().hasSelectors();
}
return super.hasSelectors();
}
/**
* Gives the count of the number of selectors in this container
* @return the number of selectors in this container
*/
public int selectorCount() {
if (isReference()) {
return getRef().selectorCount();
}
return super.selectorCount();
}
/**
* Returns the set of selectors as an array.
* @param p the current project
* @return an array of selectors in this container
*/
public FileSelector[] getSelectors(Project p) {
if (isReference()) {
return getRef().getSelectors(p);
}
return super.getSelectors(p);
}
/**
* Returns an enumerator for accessing the set of selectors.
* @return an enumerator that goes through each of the selectors
*/
public Enumeration<FileSelector> selectorElements() {
if (isReference()) {
return getRef().selectorElements();
}
return super.selectorElements();
}
/**
* Add a new selector into this container.
*
* @param selector the new selector to add
*/
public void appendSelector(FileSelector selector) {
if (isReference()) {
throw noChildrenAllowed();
}
super.appendSelector(selector);
}
/**
* Makes sure that there is only one entry, sets an error message if
* not.
*/
public void verifySettings() {
int cnt = selectorCount();
if (cnt < 0 || cnt > 1) {
setError("Only one selector is allowed within the "
+ "<selector> tag");
}
}
/**
* Ensures that the selector passes the conditions placed
* on it with <code>if</code> and <code>unless</code>.
* @return true if conditions are passed
*/
public boolean passesConditions() {
PropertyHelper ph = PropertyHelper.getPropertyHelper(getProject());
return ph.testIfCondition(ifCondition)
&& ph.testUnlessCondition(unlessCondition);
}
/**
* Sets the if attribute to an expression which must evaluate to
* true or the name of an existing property for the
* selector to select any files.
* @param ifProperty the expression to check
* @since Ant 1.8.0
*/
public void setIf(Object ifProperty) {
this.ifCondition = ifProperty;
}
/**
* Sets the if attribute to an expression which must evaluate to
* true or the name of an existing property for the
* selector to select any files.
* @param ifProperty the expression to check
*/
public void setIf(String ifProperty) {
setIf((Object) ifProperty);
}
/**
* Sets the unless attribute to an expression which must evaluate to
* false or the name of a property which cannot exist for the
* selector to select any files.
* @param unlessProperty the expression to check
* @since Ant 1.8.0
*/
public void setUnless(Object unlessProperty) {
this.unlessCondition = unlessProperty;
}
/**
* Sets the unless attribute to an expression which must evaluate to
* false or the name of a property which cannot exist for the
* selector to select any files.
* @param unlessProperty the expression to check
*/
public void setUnless(String unlessProperty) {
setUnless((Object) unlessProperty);
}
/**
* Returns true (the file is selected) only if the if property (if any)
* exists, the unless property (if any) doesn't exist, and the
* contained selector (if any) selects the file. If there is no contained
* selector, return true (because we assume that the point was to test
* the if and unless conditions).
*
* @param basedir the base directory the scan is being done from
* @param filename the name of the file to check
* @param file a java.io.File object for the filename that the selector
* can use
* @return whether the file should be selected or not
*/
public boolean isSelected(File basedir, String filename, File file) {
validate();
// Deal with if and unless properties first
if (!(passesConditions())) {
return false;
}
Enumeration<FileSelector> e = selectorElements();
if (!e.hasMoreElements()) {
return true;
}
FileSelector f = e.nextElement();
return f.isSelected(basedir, filename, file);
}
}
|
