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
232
233
234
235
|
// Copyright (C) 2001-2003 Jon A. Maxwell (JAM)
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
package net.sourceforge.jnlp;
import java.util.*;
/**
* The resources element.<p>
*
* @author <a href="mailto:jmaxwell@users.sourceforge.net">Jon A. Maxwell (JAM)</a> - initial author
* @version $Revision: 1.7 $
*/
public class ResourcesDesc {
/** the locales of these resources */
private Locale locales[];
/** the OS for these resources */
private String os[];
/** the arch for these resources */
private String arch[];
/** the JNLPFile this information is for */
private JNLPFile jnlpFile;
/** list of jars, packages, properties, and extensions */
private List<Object> resources = new ArrayList<Object>();
// mixed list makes easier for lookup code
/**
* Create a representation of one information section of the
* JNLP File.
*
* @param jnlpFile JNLP file the resources are for
* @param locales the locales of these resources
* @param os the os of these resources
* @param arch the arch of these resources
*/
public ResourcesDesc(JNLPFile jnlpFile, Locale locales[], String os[], String arch[]) {
this.jnlpFile = jnlpFile;
this.locales = locales;
this.os = os;
this.arch = arch;
}
/**
* Returns the JVMs.
*/
public JREDesc[] getJREs() {
List<JREDesc> resources = getResources(JREDesc.class);
return resources.toArray(new JREDesc[resources.size()]);
}
public static JARDesc getMainJAR(JARDesc jars[] ) {
return getMainJAR(Arrays.asList(jars));
}
public static JARDesc getMainJAR(List<JARDesc> jars) {
for (JARDesc jar : jars) {
if (jar.isMain()) {
return jar;
}
}
if (jars.size() > 0) {
return jars.get(0);
} else {
return null;
}
}
/**
* Returns the main JAR for these resources. There first JAR
* is returned if no JARs are specified as the main JAR, and if
* there are no JARs defined then null is returned.
*/
public JARDesc getMainJAR() {
return getMainJAR(getJARs());
}
/**
* Returns all of the JARs.
*/
public JARDesc[] getJARs() {
List<JARDesc> resources = getResources(JARDesc.class);
return resources.toArray(new JARDesc[resources.size()]);
}
/**
* Returns the JARs with the specified part name.
*
* @param partName the part name, null and "" equivalent
*/
public JARDesc[] getJARs(String partName) {
List<JARDesc> resources = getResources(JARDesc.class);
for (int i = resources.size(); i-- > 0;) {
JARDesc jar = resources.get(i);
if (!("" + jar.getPart()).equals("" + partName))
resources.remove(i);
}
return resources.toArray(new JARDesc[resources.size()]);
}
/**
* Returns the Extensions.
*/
public ExtensionDesc[] getExtensions() {
List<ExtensionDesc> resources = getResources(ExtensionDesc.class);
return resources.toArray(new ExtensionDesc[resources.size()]);
}
/**
* Returns the Packages.
*/
public PackageDesc[] getPackages() {
List<PackageDesc> resources = getResources(PackageDesc.class);
return resources.toArray(new PackageDesc[resources.size()]);
}
/**
* Returns the Packages that match the specified class name.
*
* @param className the fully qualified class name
* @return the PackageDesc objects matching the class name
*/
public PackageDesc[] getPackages(String className) {
List<PackageDesc> resources = getResources(PackageDesc.class);
for (int i = resources.size(); i-- > 0;) {
PackageDesc pk = resources.get(i);
if (!pk.matches(className))
resources.remove(i);
}
return resources.toArray(new PackageDesc[resources.size()]);
}
/**
* Returns the Properties as a list.
*/
public PropertyDesc[] getProperties() {
List<PropertyDesc> resources = getResources(PropertyDesc.class);
return resources.toArray(new PropertyDesc[resources.size()]);
}
/**
* Returns the properties as a map.
*/
public Map<String, String> getPropertiesMap() {
Map<String, String> properties = new HashMap<String, String>();
List<PropertyDesc> resources = getResources(PropertyDesc.class);
for (PropertyDesc prop : resources) {
properties.put(prop.getKey(), prop.getValue());
}
return properties;
}
/**
* Returns the os required by these resources, or null if no
* locale was specified in the JNLP file.
*/
public String[] getOS() {
return os;
}
/**
* Returns the architecture required by these resources, or null
* if no locale was specified in the JNLP file.
*/
public String[] getArch() {
return arch;
}
/**
* Returns the locale required by these resources, or null if no
* locale was specified in the JNLP file.
*/
public Locale[] getLocales() {
return locales;
}
/**
* Returns the JNLPFile the resources are for.
*/
public JNLPFile getJNLPFile() {
return jnlpFile;
}
/**
* Returns all resources of the specified type.
*/
public <T> List<T> getResources(Class<T> type) {
List<T> result = new ArrayList<T>();
for (Object resource : resources) {
if (type.isAssignableFrom(resource.getClass()))
result.add(type.cast(resource));
}
return result;
}
/**
* Add a resource.
*/
public void addResource(Object resource) {
// if this is going to stay public it should probably take an
// interface instead of an Object
if (resource == null)
throw new IllegalArgumentException("null resource");
resources.add(resource);
}
}
|
