Author: thimel Date: 2009-04-30 17:01:48 +0000 (Thu, 30 Apr 2009) New Revision: 488 Added: eugene/trunk/src/main/java/org/nuiton/eugene/ImportsManager.java eugene/trunk/src/test/java/org/nuiton/eugene/ImportsManagerTest.java Log: Add ImportsManager and its test Added: eugene/trunk/src/main/java/org/nuiton/eugene/ImportsManager.java =================================================================== --- eugene/trunk/src/main/java/org/nuiton/eugene/ImportsManager.java (rev 0) +++ eugene/trunk/src/main/java/org/nuiton/eugene/ImportsManager.java 2009-04-30 17:01:48 UTC (rev 488) @@ -0,0 +1,114 @@ +package org.nuiton.eugene; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Set; + +/** + * Class used in generators that allows to manage easily imports. A first-pass + * allow to register imports, and in a second-pass, returns the type to use in + * generated code. + * + * @author thimel, chemit + */ +public class ImportsManager { + + private static Set<String> primitiveTypes; + static { + primitiveTypes = new HashSet<String>(); + + primitiveTypes.add("byte"); + primitiveTypes.add("Byte"); + primitiveTypes.add("short"); + primitiveTypes.add("Short"); + primitiveTypes.add("int"); + primitiveTypes.add("Integer"); + primitiveTypes.add("long"); + primitiveTypes.add("Long"); + primitiveTypes.add("float"); + primitiveTypes.add("Float"); + primitiveTypes.add("double"); + primitiveTypes.add("Double"); + + primitiveTypes.add("char"); + primitiveTypes.add("Char"); + primitiveTypes.add("String"); + + primitiveTypes.add("boolean"); + primitiveTypes.add("Boolean"); + + primitiveTypes.add("void"); + + } + + private Map<String, String> imports = new HashMap<String, String>(); + + /** + * From the given fqn, add it to the imports list. If there is a confilct + * adding this import, will return true + * @param fqn the fully qualified name to import + * @return true if there is a conflict adding the import + */ + public boolean addImport(String fqn) { + if (fqn.startsWith("java.lang.") && fqn.lastIndexOf(".") == 9) { + return false; + } + if (primitiveTypes.contains(fqn)) { + return false; + } + String name = fqn.substring(fqn.lastIndexOf(".") + 1); + String inPlaceFqn = imports.get(name); + if (inPlaceFqn == null) { + imports.put(name, fqn); + return false; + } + // if fqn is not the same, return true. Otherwise, no need to override. + return (!inPlaceFqn.equals(fqn)); + } + + /** + * Accorging to the already added types, returns the type to write in file. + * If there is a confilt, returns the fully qualified name, otherwise + * returns the simple name + * @param fqn the fully qualified name to add + * @return the fqn or simple name according to in-place imports + */ + public String getType(String fqn) { + boolean importResult = addImport(fqn); + if (importResult) { + // There is a conflict, do not use simple name + return fqn; + } else { + // No conflict, use simple name + int packageEndIndex = fqn.lastIndexOf("."); + if (packageEndIndex == -1) { + return fqn; + } else { + return fqn.substring(packageEndIndex + 1); + } + } + } + + /** + * List the imports. This method will remove the useless imports according + * to the given packageName (no need to import a class in the same package) + * @param packageName the current package name (to avoid useless imports) + * @return the imports alphabeticaly sorted + */ + public List<String> getImports(String packageName) { + List<String> result = new ArrayList<String>(); + for (String fqn : imports.values()) { + if (!(fqn.lastIndexOf(".") == packageName.length() && fqn + .startsWith(packageName + "."))) { + result.add(fqn); + } + } + Collections.sort(result); + return result; + } + +} Added: eugene/trunk/src/test/java/org/nuiton/eugene/ImportsManagerTest.java =================================================================== --- eugene/trunk/src/test/java/org/nuiton/eugene/ImportsManagerTest.java (rev 0) +++ eugene/trunk/src/test/java/org/nuiton/eugene/ImportsManagerTest.java 2009-04-30 17:01:48 UTC (rev 488) @@ -0,0 +1,83 @@ +package org.nuiton.eugene; + +import java.util.List; + +import org.nuiton.eugene.ImportsManager; + +import junit.framework.TestCase; + +public class ImportsManagerTest extends TestCase { + + private ImportsManager mgr; + + @Override + protected void setUp() throws Exception { + mgr = new ImportsManager(); + } + + public void testAddImport() throws Exception { + assertFalse(mgr.addImport("org.nuiton.eugene.Toto")); + assertFalse(mgr.addImport("org.nuiton.eugene.Toto")); //Repeat to test acceptance + assertFalse(mgr.addImport("org.nuiton.eugene.Tutu")); + assertTrue(mgr.addImport("org.chorem.eugene.Tutu")); //Conflict, package differs + + assertFalse(mgr.addImport("void")); + assertFalse(mgr.addImport("boolean")); + assertFalse(mgr.addImport("Byte")); + assertFalse(mgr.addImport("java.lang.Toto")); + assertTrue(mgr.addImport("java.lang.sub.Toto")); + } + + public void testGetType() throws Exception { + assertEquals("Toto", mgr.getType("org.nuiton.eugene.Toto")); + assertEquals("Toto", mgr.getType("org.nuiton.eugene.Toto")); //Repeat to test acceptance + assertEquals("Tutu", mgr.getType("org.nuiton.eugene.Tutu")); + assertEquals("org.chorem.eugene.Tutu", mgr.getType("org.chorem.eugene.Tutu")); //Conflict, package differs + + assertEquals("void", mgr.getType("void")); + assertEquals("boolean", mgr.getType("boolean")); + assertEquals("Byte", mgr.getType("Byte")); + assertEquals("Toto", mgr.getType("java.lang.Toto")); + assertEquals("java.lang.sub.Toto", mgr.getType("java.lang.sub.Toto")); + } + + public void testGetImports() throws Exception { + mgr.addImport("org.nuiton.eugene.Toto"); + mgr.addImport("org.nuiton.eugene.Tutu"); + mgr.addImport("org.nuiton.eugene.subpackage.Tata"); + List<String> imports = mgr.getImports("org.nuiton.eugene"); + assertEquals(1, imports.size()); + assertEquals("org.nuiton.eugene.subpackage.Tata", imports.get(0)); + + imports = mgr.getImports("org.nuiton"); + assertEquals(3, imports.size()); + // Check using alphabetic sort + assertEquals("org.nuiton.eugene.Toto", imports.get(0)); + assertEquals("org.nuiton.eugene.Tutu", imports.get(1)); + assertEquals("org.nuiton.eugene.subpackage.Tata", imports.get(2)); + + imports = mgr.getImports("org.chorem"); + assertEquals(3, imports.size()); + + imports = mgr.getImports("org.nuiton.eugene.subpackage"); + assertEquals(2, imports.size()); + assertEquals("org.nuiton.eugene.Toto", imports.get(0)); + assertEquals("org.nuiton.eugene.Tutu", imports.get(1)); + + mgr.addImport("java.lang.String"); + imports = mgr.getImports("org.nuiton.eugene.subpackage"); + assertEquals(2, imports.size()); + assertEquals("org.nuiton.eugene.Toto", imports.get(0)); + assertEquals("org.nuiton.eugene.Tutu", imports.get(1)); + + mgr.addImport("void"); + mgr.addImport("boolean"); + mgr.addImport("Byte"); + mgr.addImport("java.lang.Toto"); + mgr.addImport("java.lang.sub.Toto"); + imports = mgr.getImports("org.nuiton.eugene.subpackage"); + assertEquals(2, imports.size()); + + } + +}