|
Scala example source code file (ScalaClassLoader.scala)
The ScalaClassLoader.scala Scala example source code/* NSC -- new Scala compiler * Copyright 2005-2013 LAMP/EPFL * @author Paul Phillips */ package scala package reflect.internal.util import java.lang.{ ClassLoader => JClassLoader } import java.lang.reflect.{ Constructor, Modifier, Method } import java.io.{ File => JFile } import java.net.{ URLClassLoader => JURLClassLoader } import java.net.URL import scala.reflect.runtime.ReflectionUtils.unwrapHandler import ScalaClassLoader._ import scala.util.control.Exception.{ catching } import scala.language.implicitConversions import scala.reflect.{ ClassTag, classTag } trait HasClassPath { def classPathURLs: Seq[URL] } /** A wrapper around java.lang.ClassLoader to lower the annoyance * of java reflection. */ trait ScalaClassLoader extends JClassLoader { /** Executing an action with this classloader as context classloader */ def asContext[T](action: => T): T = { val saved = contextLoader try { setContext(this) ; action } finally setContext(saved) } def setAsContext() { setContext(this) } /** Load and link a class with this classloader */ def tryToLoadClass[T <: AnyRef](path: String): Option[Class[T]] = tryClass(path, initialize = false) /** Load, link and initialize a class with this classloader */ def tryToInitializeClass[T <: AnyRef](path: String): Option[Class[T]] = tryClass(path, initialize = true) private def tryClass[T <: AnyRef](path: String, initialize: Boolean): Option[Class[T]] = catching(classOf[ClassNotFoundException], classOf[SecurityException]) opt Class.forName(path, initialize, this).asInstanceOf[Class[T]] /** Create an instance of a class with this classloader */ def create(path: String): AnyRef = tryToInitializeClass[AnyRef](path).map(_.newInstance()).orNull /** The actual bytes for a class file, or an empty array if it can't be found. */ def classBytes(className: String): Array[Byte] = classAsStream(className) match { case null => Array() case stream => scala.reflect.io.Streamable.bytes(stream) } /** An InputStream representing the given class name, or null if not found. */ def classAsStream(className: String) = getResourceAsStream(className.replaceAll("""\.""", "/") + ".class") /** Run the main method of a class to be loaded by this classloader */ def run(objectName: String, arguments: Seq[String]) { val clsToRun = tryToInitializeClass(objectName) getOrElse ( throw new ClassNotFoundException(objectName) ) val method = clsToRun.getMethod("main", classOf[Array[String]]) if (!Modifier.isStatic(method.getModifiers)) throw new NoSuchMethodException(objectName + ".main is not static") try asContext(method.invoke(null, Array(arguments.toArray: AnyRef): _*)) // !!! : AnyRef shouldn't be necessary catch unwrapHandler({ case ex => throw ex }) } } /** Methods for obtaining various classloaders. * appLoader: the application classloader. (Also called the java system classloader.) * extLoader: the extension classloader. * bootLoader: the boot classloader. * contextLoader: the context classloader. */ object ScalaClassLoader { /** Returns loaders which are already ScalaClassLoaders unaltered, * and translates java.net.URLClassLoaders into scala URLClassLoaders. * Otherwise creates a new wrapper. */ implicit def apply(cl: JClassLoader): ScalaClassLoader = cl match { case cl: ScalaClassLoader => cl case cl: JURLClassLoader => new URLClassLoader(cl.getURLs.toSeq, cl.getParent) case _ => new JClassLoader(cl) with ScalaClassLoader } def contextLoader = apply(Thread.currentThread.getContextClassLoader) def appLoader = apply(JClassLoader.getSystemClassLoader) def setContext(cl: JClassLoader) = Thread.currentThread.setContextClassLoader(cl) def savingContextLoader[T](body: => T): T = { val saved = contextLoader try body finally setContext(saved) } class URLClassLoader(urls: Seq[URL], parent: JClassLoader) extends JURLClassLoader(urls.toArray, parent) with ScalaClassLoader with HasClassPath { private var classloaderURLs: Seq[URL] = urls def classPathURLs: Seq[URL] = classloaderURLs /** Override to widen to public */ override def addURL(url: URL) = { classloaderURLs :+= url super.addURL(url) } } def fromURLs(urls: Seq[URL], parent: ClassLoader = null): URLClassLoader = new URLClassLoader(urls, parent) /** True if supplied class exists in supplied path */ def classExists(urls: Seq[URL], name: String): Boolean = (fromURLs(urls) tryToLoadClass name).isDefined /** Finding what jar a clazz or instance came from */ def originOfClass(x: Class[_]): Option[URL] = Option(x.getProtectionDomain.getCodeSource) flatMap (x => Option(x.getLocation)) } Other Scala source code examplesHere is a short list of links related to this Scala ScalaClassLoader.scala source code file: |
... this post is sponsored by my books ... | |
#1 New Release! |
FP Best Seller |
Copyright 1998-2024 Alvin Alexander, alvinalexander.com
All Rights Reserved.
A percentage of advertising revenue from
pages under the /java/jwarehouse
URI on this website is
paid back to open source projects.