1 package demoRunner;
2
3
4 import java.io.BufferedReader;
5 import java.io.File;
6 import java.io.FileInputStream;
7 import java.io.FileNotFoundException;
8 import java.io.FilenameFilter;
9 import java.io.IOException;
10 import java.io.InputStreamReader;
11 import java.lang.reflect.InvocationTargetException;
12 import java.lang.reflect.Method;
13 import java.net.URL;
14 import java.util.ArrayList;
15 import java.util.Comparator;
16 import java.util.Iterator;
17 import java.util.List;
18 import java.util.jar.JarEntry;
19 import java.util.jar.JarInputStream;
20 import java.util.regex.Matcher;
21 import java.util.regex.Pattern;
22
23
24
30 public class DemoRunner {
31
32
33
39 public static void run(String args[],String packageName, String noRunName) {
40 if (args.length > 1) {
41 System.out
42 .println("Anna parametrina vain yhden ajettavan demon nimi.\n"
43 + "Jos et anna parametreja, voit valita ajettavan demon "
44 + "listasta.");
45 System.exit(1);
46 }
47
48
49 DemoRunner demo = new DemoRunner(packageName,noRunName);
50
51 String msg = "";
52 if (args.length == 0) {
53 msg = demo.runInteractively();
54 } else {
55 msg = demo.runWithArgs(args);
56 }
57 System.out.println(msg);
58 }
59
60 private ClassList classes;
61
62
67 public DemoRunner(String packageName, String noRunName) {
68 classes = new ClassList(packageName,noRunName);
69 classes.sort();
70 }
71
72
77 public String runWithArgs(String[] args) {
78 String sampleName = args[0];
79 String[] restOfArgs = new String[args.length-1];
82 for (int i = 0; i<args.length-1; ++i) {
83 restOfArgs[i] = args[i+1];
84 }
85 Class<?> sampleClass = classes.get(sampleName);
86 if (sampleClass == null)
87 return "Demoa " + sampleName + " ei ole.";
88 runDemo(sampleClass, restOfArgs);
89 return "";
90 }
91
92
96 public String runInteractively() {
97 String resultMessage = "";
98
99 System.out.println("Valitse ajettava demo");
100
101 int number = 0;
102 for (Class<?> aClass : classes) {
103 System.out.printf(" %d. %s\n", number++, aClass.getName());
104 }
105
106 BufferedReader consoleInputStream = new BufferedReader(
107 new InputStreamReader(System.in));
108
109 while (true) {
110 try {
111 System.out.print("Anna ajettavan demon numero: ");
112 String response = consoleInputStream.readLine();
113 if (response.equals("")) {
114 break;
115 }
116 int index = Integer.parseInt(response);
117 Class<?> sampleClass = classes.get(index);
118 runDemo(sampleClass, null);
119 resultMessage = "";
120 break;
121 } catch (IOException e) {
122 resultMessage = "Demoa ei voitu ajaa: "
123 + e.getLocalizedMessage();
124 System.err.println(resultMessage);
125 } catch (NumberFormatException e) {
126 System.out.println("Anna numero 0..." + (classes.size() - 1));
127 resultMessage = "";
128 } catch (IndexOutOfBoundsException e) {
129 System.out.println("Anna numero 0..." + (classes.size() - 1));
130 resultMessage = "";
131 }
132 }
133
134 return resultMessage;
135 }
136
137 private void runDemo(Class<?> sampleClass, String[] args) {
138 try {
139 Object objectParameters[] = { new String[] {} };
140 Class<?> classParameters[] = { objectParameters[0].getClass() };
141 Method mainMethod = sampleClass.getDeclaredMethod("main",
142 classParameters);
143 mainMethod.invoke(null, (Object) args);
144 } catch (SecurityException e) { e.printStackTrace(System.err); } catch (IllegalArgumentException e) { e.printStackTrace(System.err); } catch (NoSuchMethodException e) {
149 e.printStackTrace(System.err);
150 } catch (IllegalAccessException e) {
151 e.printStackTrace(System.err);
152 } catch (InvocationTargetException e) {
153 e.printStackTrace(System.err);
154 }
155 }
156
157
158
162 public static class ClassList implements Iterable<Class<?>> {
163 private List<Class<?>> classes;
164 private String packageOfClasses;
165 private String noRunName;
166
167
173 private boolean isAllowed(String name,String noRunName) {
174 return !name.endsWith(noRunName+".class");
175 }
176
177
178
183 public ClassList(String packageName,String noRunName) {
184 classes = new ArrayList<Class<?>>();
185 add(packageName, noRunName);
186 }
187
188
193 public final void add(String packageName,String noRunName) {
194 String thisPackageName = DemoRunner.class.getPackage().getName();
195 String thisName = DemoRunner.class.getSimpleName();
196 this.noRunName = noRunName;
197 packageOfClasses = packageName;
198 URL demoURL = DemoRunner.class.getResource(thisName+".class");
199 File classFile = new File(demoURL.toExternalForm());
200 String pathnameOfClass = classFile.getParentFile().getPath();
201
202 String[] packagePath = pathnameOfClass.split("!")[0].split(":");
203 String thisPackage = packagePath[packagePath.length - 1];
204 String packageRoot = thisPackage.substring(0,thisPackage.length()-thisPackageName.length());
205
206 if (packagePath[0].equals("jar")) {
207 String packageFileName = thisPackage;
208 File packageFile = new File(packageFileName);
209 classesInJar(packageFile);
210 } else {
211 String packageFileName = packageRoot+File.separator+packageName;
212 File packageFile = new File(packageFileName);
213 classesInDirectory(packageFile);
214 }
215 }
216
217 private void classesInDirectory(final File directory) {
218 File[] files = directory.listFiles(new FilenameFilter() {
219 public boolean accept(File dir, String name) {
220 return dir.equals(directory) && name.endsWith(".class")
221 && !name.contains("$") && isAllowed(name, noRunName);
222 }
223 });
224 for (File file : files) {
225 loadSampleClass(file);
226 }
227 }
228
229 private void classesInJar(File jarFile) {
230 JarInputStream jarStream = null;
231 try {
232 jarStream = new JarInputStream(new FileInputStream(jarFile));
233 JarEntry jarEntry = jarStream.getNextJarEntry();
234 while (jarEntry != null) {
235 if (jarEntry.toString().endsWith(".class") && isAllowed(jarEntry.toString(),noRunName) ) {
236
237 Pattern pp = Pattern.compile(packageOfClasses
238 + "/([\\w\\d_]+)\\.class");
239 Matcher mm = pp.matcher(jarEntry.toString());
240 if (mm.matches()) {
241 loadSampleClass(mm.group(1));
242 }
243 }
244 try {
245 jarEntry = jarStream.getNextJarEntry();
246 } catch (IOException e) {
247 }
249 }
250 } catch (FileNotFoundException e) { e.printStackTrace(System.err); } catch (IOException e) { e.printStackTrace(System.err);
257 }
258 }
259
260
261
265 public Iterator<Class<?>> iterator() {
266 return classes.iterator();
267 }
268
269
272 public void sort() {
273 java.util.Collections.sort(classes, new Comparator<Class<?>>() {
274 public int compare(Class<?> o1, Class<?> o2) {
275 return o1.getName().compareTo(o2.getName());
276 }
277 });
278 }
279
280
287 public Class<?> get(String sampleName) {
288 for (Class<?> aClass : this) {
289 if (aClass.getName().endsWith(sampleName)) {
290 return aClass;
291 }
292 }
293 return null;
294 }
295
296
305 public Class<?> get(int index) throws IndexOutOfBoundsException {
306 return classes.get(index);
307 }
308
309
315 public int size() {
316 return classes.size();
317 }
318
319 private Class<?> loadSampleClass(File file) {
320 String filename = file.getName();
321 return loadSampleClass(filename.substring(0, filename
322 .lastIndexOf(".")));
323 }
324
325 private Class<?> loadSampleClass(String fname) {
326 Class<?> candidateClass = null;
327
328 try {
329 candidateClass = java.lang.Class.forName(packageOfClasses
330 + "." + fname, true, ClassLoader.getSystemClassLoader());
331 } catch (ClassNotFoundException e) {
332 return null;
333 }
334 classes.add(candidateClass);
335 return candidateClass;
336 }
337
338 }
339
340 }
341
342