Slight generator optimizations

- removed shuffling to have predictable build times
- added "random" generic types
- fixed "random" imports / fields
- added primitive arguments support (roots, depth, classes, path)
- consistently using "Foo" instead of "Element" base type names

Author: iloveeclipse

JavaProjectGenerator/src/de/loskutov/jpg/Clazz.java

@@ -17,11 +17,12 @@ String generateCode() {
 		if(object) {
 			return generateObject();
 		}
+		String type = genTypes.next();
 		String s = "package " + packageName + ";\n\n" + 
 				"import " + imports.next() + ";\n\n" +
 				"@SuppressWarnings(\"all\")\n" +
-				"public abstract class " + name + "<E> extends " + extend + "<E> implements " + implement + "<E> {\n\n" + 
-					"\t public E element;\n\n" +
+				"public abstract class " + name + "<"+type+"> extends " + extend + "<"+type+"> implements " + implement + "<"+type+"> {\n\n" + 
+					"\t public "+type+" element;\n\n" +
 					"\t public " + fields.next() + " field1;\n\n" +
 					"\t public static " + name + " instance;\n\n" +
 					"\t public static " + name + " getInstance() {\n" +
@@ -37,26 +38,27 @@ String generateCode() {
 					"\t \t " + extend + ".getInstance().setName(getName());\n" +
 					"\t \t return;\n" +
 					"\t }\n\n" +
-					"\t public E get() {\n" +
-					"\t \t return (E)" + extend + ".getInstance().get();\n" +
+					"\t public "+type+" get() {\n" +
+					"\t \t return ("+type+")" + extend + ".getInstance().get();\n" +
 					"\t }\n\n" +
 					"\t public void set(Object element) {\n" +
-					"\t \t this.element = (E)element;\n" +
+					"\t \t this.element = ("+type+")element;\n" +
 					"\t \t " + extend + ".getInstance().set(this.element);\n" +
 					"\t }\n\n" +
-					"\t public E call() throws Exception {\n" +
-					"\t \t return (E)" + extend + ".getInstance().call();\n" +
+					"\t public "+type+" call() throws Exception {\n" +
+					"\t \t return ("+type+")" + extend + ".getInstance().call();\n" +
 					"\t }\n" +
 				"}\n";
 		return s;
 	}
 
 	String generateObject() {
+		String type = genTypes.next();
 		String s = "package " + packageName + ";\n" + 
 				"import " + imports.next() + ";\n" +
 				"@SuppressWarnings(\"all\")\n" +
-				"public abstract class " + name + "<E> implements " + implement + "<E> {\n" + 
-					"public E element;\n" +
+				"public abstract class " + name + "<"+type+"> implements " + implement + "<"+type+"> {\n" + 
+					"public "+type+" element;\n" +
 					"public " + fields.next() + " field1;\n" +
 					"public static " + name + " instance;\n" +
 					"public static " + name + " getInstance() {\n" +
@@ -75,16 +77,16 @@ String generateObject() {
 					"\t return;\n" +
 					"}\n" +
 
-					"public E get() {\n" +
+					"public "+type+" get() {\n" +
 					"\t return element;\n" +
 					"}\n" +
 
 					"public void set(Object element) {\n" +
-					"\t this.element = (E)element;\n" +
+					"\t this.element = ("+type+")element;\n" +
 					"}\n" +
 
-					"public E call() throws Exception {\n" +
-					"\t return (E)getInstance().call();\n" +
+					"public "+type+" call() throws Exception {\n" +
+					"\t return ("+type+")getInstance().call();\n" +
 					"}\n" +
 					"}\n";
 		return s;

JavaProjectGenerator/src/de/loskutov/jpg/Interface.java

@@ -11,20 +11,21 @@ public class Interface extends JavaElement {
 
 	@Override
 	String generateCode() {
+		String type = genTypes.next();
 		String s = "package " + packageName + ";\n\n" + 
 				"import " + imports.next() + ";\n\n" +
 				"@SuppressWarnings(\"all\")\n" +
-				"public interface " + name + "<E> extends " + extend + "<E> {\n\n" + 
+				"public interface " + name + "<"+type+"> extends " + extend + "<"+type+"> {\n\n" + 
 
 				     "\t " + fields.next() + " ifield = null;\n\n" +
 
 					"\t String getName();\n\n" +
 
 					"\t void setName(String s);\n\n" +
 
-					"\t E get();\n\n" +
+					"\t "+type+" get();\n\n" +
 
-					"\t void set(E e);\n\n" +
+					"\t void set("+type+" e);\n\n" +
 				"}\n";
 		return s;
 	}

JavaProjectGenerator/src/de/loskutov/jpg/JavaElement.java

@@ -8,6 +8,8 @@
 import java.nio.file.Path;
 import java.util.Arrays;
 import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
 
 public abstract class JavaElement {
 
@@ -45,16 +47,18 @@ public abstract class JavaElement {
 			"javax.rmi.ssl.SslRMIClientSocketFactory"
 			);
 
+	static List<String> LETTERS = IntStream.rangeClosed('A', 'Z').mapToObj(x -> String.valueOf((char)x))
+			.collect(Collectors.toList());
+	
 	String name;
 	String packageName;
-	Ring<String> imports;
-	Ring<String> fields;
+	static Ring<String> imports = new Ring<>(IMPORTS);
+	static Ring<String> fields = new Ring<>(FIELDS); 
+	static Ring<String> genTypes = new Ring<>(LETTERS);
 
 	JavaElement(String name, String packageName){
 		this.name = name;
 		this.packageName = packageName;
-		imports = new Ring<>(IMPORTS);
-		fields = new Ring<>(FIELDS); 
 	}
 
 	abstract String generateCode();

JavaProjectGenerator/src/de/loskutov/jpg/Main.java

@@ -14,26 +14,40 @@
 import java.util.stream.Stream;
 
 public class Main {
-	
+
 	public static void main(String[] args) throws IOException {
-		File rootDir = new File("./target/generated/");
-        System.out.println("Writing to "  + rootDir.getAbsolutePath());
-        Path root = rootDir.toPath();
-		
-		
+		String pathname = "./target/generated/";
+
+        int roots = 10;
 		int depth = 10;
-		int roots = 10;
 		int classes = 100;
+		if(args.length == 0) {
+			System.out.println("No arguments given, using defaults");
+		} else {
+			try {
+				roots = Integer.parseUnsignedInt(args[0]);
+				depth = Integer.parseUnsignedInt(args[1]);
+				classes = Integer.parseUnsignedInt(args[2]);
+				pathname = args[3];
+			} catch(Exception e) {
+				//
+			}
+		}
+		File rootDir = new File(pathname);
+		Path root = rootDir.toPath();
+		System.out.println("Writing to "  + rootDir.getAbsolutePath());
+		System.out.println("Roots: " + roots + ", depth: " + depth + ", classes & interfaces per package: " + (classes*2));
+		System.out.println("Will generate " + roots + "x" + depth + "x" + classes + "x2 + 2 = " + (depth * roots* classes * 2 + 2) + " files");
 
 		new JavaBuilder(depth, roots, classes, root).build();
 	}
 }
 
 class JavaBuilder {
-	
+
 	static List<String> namesList = IntStream.rangeClosed('a', 'z').mapToObj(x -> String.valueOf((char)x))
 			.collect(Collectors.toList());
-	
+
 	int depth;
 	int roots;
 	private Ring<String> pnames;
@@ -44,7 +58,7 @@ class JavaBuilder {
 	private List<Interface> interfaces;
 
 	private int countClasses;
-	
+
 	public JavaBuilder(int depth, int roots, int countClasses, Path root) {
 		this.depth = depth;
 		this.roots = roots;
@@ -54,7 +68,7 @@ public JavaBuilder(int depth, int roots, int countClasses, Path root) {
 		classes = new ArrayList<>();
 		interfaces = new ArrayList<>();
 	}
-	
+
 	void build() throws IOException {
 		Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
 			   @Override
@@ -70,13 +84,13 @@ public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOEx
 			   }
 			});
 		Files.createDirectories(root);
-		
+
 		List<Package> rootPackages = new ArrayList<>();
 		for (int i = 0; i < roots; i++) {
 			Package p = createPackage(pnames.next(), null);
 			rootPackages.add(p);
 		}
-		
+
 		for (Package r : rootPackages) {
 			Stream<Package> stream = Stream.iterate(r, x -> new Package(pnames.next(), x)).limit(depth);
 			stream.forEach(p -> {
@@ -97,30 +111,30 @@ private void generateFile(JavaElement e) {
 			e1.printStackTrace();
 		}
 	}
-	
+
 	void createInterfaces(Package p) {
 		Ring<Interface> toImplement = new Ring<>(interfaces, countClasses);
 		if(interfaces.isEmpty()) {
 			interfaces.add(new Interface("IFoo0", p.getFqn(), "java.util.concurrent.Callable"));
 		}
-		toImplement.stream().forEach(i -> {				
+		toImplement.stream().forEach(i -> {
 			interfaces.add(new Interface("IFoo" + interfaces.size(), p.getFqn(), toImplement.next().fqn()));
 		});
 	}
-	
+
 	void createClasses(Package p) {
 		Ring<Interface> implement = new Ring<>(interfaces, countClasses);
 		Ring<Clazz> toExtend = new Ring<>(classes, countClasses);
 		if (classes.isEmpty()) {
-			classes.add(new Clazz("Element0", p.getFqn(), implement.next().fqn(), "java.lang.Object"));
+			classes.add(new Clazz("Foo0", p.getFqn(), implement.next().fqn(), "java.lang.Object"));
 		}
 		toExtend.stream().forEach(x -> {
-			classes.add(new Clazz("Element" + classes.size(), p.getFqn(), implement.next().fqn(), toExtend.next().fqn()));
+			classes.add(new Clazz("Foo" + classes.size(), p.getFqn(), implement.next().fqn(), toExtend.next().fqn()));
 		});
 	}
-	
+
 	Package createPackage(String name, Package parent) {
 		return new Package(name, parent);
 	}
-	
+
 }

JavaProjectGenerator/src/de/loskutov/jpg/Ring.java

@@ -9,31 +9,31 @@ public class Ring<E> {
 	private List<E> choices;
 	int cursor = -1;
 	private int limit;
-	
+
 	Ring(List<E> list){
 		this(list, -1);
 	}
-	
+
 	Ring(List<E> list, int limit){
 		this.limit = limit;
 		if(list instanceof ArrayList) {
 			this.choices = list;
 		} else {
 			this.choices = new ArrayList<>(list);
 		}
-		Collections.shuffle(choices);
+//		Collections.shuffle(choices);
 	}
-	
+
 	E next() {
 		cursor ++;
 		if(cursor >= choices.size()) {
 			cursor = 0;
 		}
 		return choices.get(cursor);
 	}
-	
+
 	Stream<E> stream(){
-		if(limit > 0) {			
+		if(limit > 0) {
 			return Stream.generate(() -> next()).limit(limit);
 		}
 		return Stream.generate(() -> next());