please, provide a groovy.lang.GroovyClassLoader.ClassCollector.generatedClass atribute getter

Marcius da Silva da Fonseca added a comment - 07/Nov/08 1:20 PM - edited I have a couple of class sources in a table on the database. In a very simple example: if I have a "Class_A" that depends on "Class_B", and I do... ParseClass("Class_A"); ...groovy will see that Class_A depends on Class_B, but if a had not set a classpath nor added a URL with "addURL(myURL)", groovy will not be able to resolve de dependency(ies). I can't say to a GroovyClassLoader "my classpath is this table in my database" nor do something like addSource(an sourcecode got from my table). The interface GroovyResourceLoader only has one method that returns a URL, but my classes are in DB... how could it help-me? I wanted to give a classname to it and receive the actual sourcecode, since my classes are in database, not in the filesystem... So, I solved this creating a class that I called GroovyDBClassLoader (extends GroovyClassLoader) that overwrites parseClass() in a way that when I pass a classname to it, it will get the sourcecode for the given classname from the database, fetch its dependencies and parse everything (including the dependencies) in the same CompilationUnit and return the generatedClass. To do this, I needed access the "generatedClass" attribute in the groovy.lang.GroovyClassLoader.ClassCollector, but it is privated... Well, so I got the groovy sources, modified it creating a getter to "generatedClass" at groovy.lang.GroovyClassLoader.ClassCollector, and repack it in a groovy-all-xxx.jar here is a resume of my GroovyDBClassLoader: public class GroovyDBClassLoader extends GroovyClassLoader { // ... here lies some omited code .... public Class parseDBClass( String classname, boolean shouldParseDeps, boolean shouldCacheSource) throws ClassNotFoundException { synchronized (sourceCache) { Class answer = ( Class ) sourceCache.get(classname); if (answer != null ) { return answer; } // Was neither already loaded nor compiled, // so compile and add to cache. // get the source-code(s) Map< String , GroovyCodeSource> codeSources; if (shouldParseDeps) { // will load all dependant classes from database, starting from the root "classname" codeSources = resourceLoader.loadSourceAndDeps(classname); } else { // will load only the root "classname" // usefull when the class we want to parse is self-contained... codeSources = new HashMap< String , GroovyCodeSource>(); codeSources.put(classname, resourceLoader.loadSource(classname)); } // the root class will be the aswer of this method, but the dependencies will be // loaded as well (and put in the classCache) GroovyCodeSource mainCodeSource = codeSources.remove(classname); // create a compilation unit CompilationUnit unit = createCompilationUnit(config, mainCodeSource.getCodeSource()); // add the main source. su points to the root class SourceUnit su = unit.addSource(mainCodeSource.getName(), mainCodeSource.getInputStream()); // add the dependencies Collection<GroovyCodeSource> dependencies = codeSources.values(); for (GroovyCodeSource cs : dependencies) { // if some of the dependencies is loaded already, dont parse it again... if (classCache.get(cs.getName()) == null ) { unit.addSource(cs.getName(), cs.getInputStream()); } } // create a class collector to get the classes after compilation GroovyClassLoader.ClassCollector collector = createCollector(unit, su); unit.setClassgenCallback(collector); // set the compilation goal phase int goalPhase = Phases.CLASS_GENERATION; if (config != null && config.getTargetDirectory() != null ) { goalPhase = Phases.OUTPUT; } // compile unit.compile(goalPhase); // the class to return // HERE IS WERE I NEEDED TO ACCESS THE "generatedClass" FIELD!!! answer = collector.getGeneratedClass(); // if the class to return is cacheable, put it into the cache. if (mainCodeSource != null && mainCodeSource.isCachable()) { sourceCache.put(classname, answer); } // make all dependencies avaliable Collection< Class > loadedClasses = collector.getLoadedClasses(); for ( Class clazz : loadedClasses) { setClassCacheEntry(clazz); // if the dependency classes are cacheable, put them into the cache. String clazzname = clazz.getName(); GroovyCodeSource cs = codeSources.remove(clazzname); if (cs != null && cs.isCachable()) { sourceCache.put(clazzname, clazz); } } return answer; } } // ... some more code ... } as you can see, I use a ResourceLoader, but this one is not the GroovyResourceLoader (cause it returns only URLs). I've written my on DatabaseResourceLoader... Well... here is a resume of what I'm trying to do (with sample codes): http://www.groovy-forum.org/viewtopic.php?t=511&sid=847d91df6a3a95ca53875c4bdfd07d99 thanks