Field Detail

• protected final Map<String, Class> classCache

  this cache contains the loaded classes or PARSING, if the class is currently parsed

• protected final Map<String, Class> sourceCache

  This cache contains mappings of file name to class. It is used to bypass compilation.

Constructor Detail

• public GroovyClassLoader()

  creates a GroovyClassLoader using the current Thread's context Class loader as parent.

• public GroovyClassLoader(ClassLoader loader)

  creates a GroovyClassLoader using the given ClassLoader as parent

• public GroovyClassLoader(GroovyClassLoader parent)

  creates a GroovyClassLoader using the given GroovyClassLoader as parent. This loader will get the parent's CompilerConfiguration

• public GroovyClassLoader(ClassLoader parent, CompilerConfiguration config, boolean useConfigurationClasspath)

  creates a GroovyClassLoader.

  Parameters:

  parent - the parent class loader

  config - the compiler configuration

  useConfigurationClasspath - determines if the configurations classpath should be added

• public GroovyClassLoader(ClassLoader loader, CompilerConfiguration config)

  creates a GroovyClassLoader using the given ClassLoader as parent.

Method Detail

• public void addClasspath(String path)

  adds a classpath to this classloader.

  Parameters:

  path - is a jar file or a directory.

  See Also:

  addURL(URL)

• public void addURL(URL url)

  adds a URL to the classloader.

  Parameters:

  url - the new classpath element

• public void clearCache()

  Removes all classes from the class cache.

  See Also:

  getClassCacheEntry(String)

  setClassCacheEntry(Class)

  removeClassCacheEntry(String)

• protected GroovyClassLoader.ClassCollector createCollector(CompilationUnit unit, SourceUnit su)

  creates a ClassCollector for a new compilation.

  Parameters:

  unit - the compilationUnit

  su - the SourceUnit

  Returns:

  the ClassCollector

• protected CompilationUnit createCompilationUnit(CompilerConfiguration config, CodeSource source)

  creates a new CompilationUnit. If you want to add additional phase operations to the CompilationUnit (for example to inject additional methods, variables, fields), then you should overwrite this method.

  Parameters:

  config - the compiler configuration, usually the same as for this class loader

  source - the source containing the initial file to compile, more files may follow during compilation

  Returns:

  the CompilationUnit

• public Class defineClass(ClassNode classNode, String file, String newCodeBase)

  Loads the given class node returning the implementation Class.

  WARNING: this compilation is not synchronized

  Parameters:

  classNode

  Returns:

  a class

• public Class defineClass(String name, byte[] b)

  open up the super class define that takes raw bytes

• public String generateScriptName()

• protected Class getClassCacheEntry(String name)

  gets a class from the class cache. This cache contains only classes loaded through this class loader or an InnerLoader instance. If no class is stored for a specific name, then the method should return null.

  Parameters:

  name - of the class

  Returns:

  the class stored for the given name

  See Also:

  removeClassCacheEntry(String)

  setClassCacheEntry(Class)

  clearCache()

• protected String[] getClassPath()

  gets the currently used classpath.

  Returns:

  a String[] containing the file information of the urls

  See Also:

  getURLs()

• public Class[] getLoadedClasses()

  Returns all Groovy classes loaded by this class loader.

  Returns:

  all classes loaded by this class loader

• protected PermissionCollection getPermissions(CodeSource codeSource)

• public GroovyResourceLoader getResourceLoader()

• protected long getTimeStamp(Class cls)

  gets the time stamp of a given class. For groovy generated classes this usually means to return the value of the static field __timeStamp. If the parameter doesn't have such a field, then Long.MAX_VALUE is returned

  Parameters:

  cls - the class

  Returns:

  the time stamp

• protected boolean isRecompilable(Class cls)

  Indicates if a class is recompilable. Recompilable means, that the classloader will try to locate a groovy source file for this class and then compile it again, adding the resulting class as entry to the cache. Giving null as class is like a recompilation, so the method should always return true here. Only classes that are implementing GroovyObject are compilable and only if the timestamp in the class is lower than Long.MAX_VALUE.

  NOTE: First the parent loaders will be asked and only if they don't return a class the recompilation will happen. Recompilation also only happen if the source file is newer.

  Parameters:

  cls - the class to be tested. If null the method should return true

  Returns:

  true if the class should be compiled again

  See Also:

  isSourceNewer(URL, Class)

• public Boolean isShouldRecompile()

  gets the currently set recompilation mode. null means, the compiler configuration is used. False means no recompilation and true means that recompilation will be done if needed.

  Returns:

  the recompilation mode

• protected boolean isSourceNewer(URL source, Class cls)

  Decides if the given source is newer than a class.

  throws:

  IOException if it is not possible to open an connection for the given source

  Parameters:

  source - the source we may want to compile

  cls - the former class

  Returns:

  true if the source is newer, false else

  See Also:

  getTimeStamp(Class)

• public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript)

  loads a class from a file or a parent classloader. This method does call loadClass(String, boolean, boolean, boolean) with the last parameter set to false.

  throws:

  CompilationFailedException if compilation was not successful

• public Class loadClass(String name, boolean lookupScriptFiles, boolean preferClassOverScript, boolean resolve)

  loads a class from a file or a parent classloader.

  throws:

  ClassNotFoundException if the class could not be found

  throws:

  CompilationFailedException if the source file could not be compiled

  Parameters:

  name - of the class to be loaded

  lookupScriptFiles - if false no lookup at files is done at all

  preferClassOverScript - if true the file lookup is only done if there is no class

  resolve - see ClassLoader.loadClass

  Returns:

  the class found or the class created from a file lookup

• @Override public Class<?> loadClass(String name)

• protected Class loadClass(String name, boolean resolve)

  Implemented here to check package access prior to returning an already loaded class.

  throws:

  CompilationFailedException if the compilation failed

  throws:

  ClassNotFoundException if the class was not found

  See Also:

  ClassLoader.loadClass

• public Class parseClass(File file)

  Parses the given file into a Java class capable of being run

  Parameters:

  file - the file name to parse

  Returns:

  the main class defined in the given script

• public Class parseClass(String text, String fileName)

  Parses the given text into a Java class capable of being run

  Parameters:

  text - the text of the script/class to parse

  fileName - the file name to use as the name of the class

  Returns:

  the main class defined in the given script

• public Class parseClass(String text)

  Parses the given text into a Java class capable of being run

  Parameters:

  text - the text of the script/class to parse

  Returns:

  the main class defined in the given script

• public Class parseClass(InputStream in, String fileName)

  deprecated:

  Prefer using methods taking a Reader rather than an InputStream to avoid wrong encoding issues.

• public Class parseClass(GroovyCodeSource codeSource)

• public Class parseClass(GroovyCodeSource codeSource, boolean shouldCacheSource)

  Parses the given code source into a Java class. If there is a class file for the given code source, then no parsing is done, instead the cached class is returned.

  Parameters:

  shouldCacheSource - if true then the generated class will be stored in the source cache

  Returns:

  the main class defined in the given script

• protected Class recompile(URL source, String className, Class oldClass)

  (Re)Compiles the given source. This method starts the compilation of a given source, if the source has changed since the class was created. For this isSourceNewer is called.

  throws:

  CompilationFailedException if the compilation failed

  throws:

  IOException if the source is not readable

  Parameters:

  source - the source pointer for the compilation

  className - the name of the class to be generated

  oldClass - a possible former class

  Returns:

  the old class if the source wasn't new enough, the new class else

  See Also:

  isSourceNewer(URL, Class)

• protected void removeClassCacheEntry(String name)

  removes a class from the class cache.

  Parameters:

  name - of the class

  See Also:

  getClassCacheEntry(String)

  setClassCacheEntry(Class)

  clearCache()

• protected void setClassCacheEntry(Class cls)

  sets an entry in the class cache.

  Parameters:

  cls - the class

  See Also:

  removeClassCacheEntry(String)

  getClassCacheEntry(String)

  clearCache()

• public void setResourceLoader(GroovyResourceLoader resourceLoader)

• public void setShouldRecompile(Boolean mode)

  sets if the recompilation should be enable. There are 3 possible values for this. Any value different than null overrides the value from the compiler configuration. true means to recompile if needed false means to never recompile.

  Parameters:

  mode - the recompilation mode

  See Also:

  CompilerConfiguration