Eval

Evaluates files, strings, or input streams as Scala code, and returns the result.

If target is None, the results are compiled to memory (and are therefore ephemeral). If target is Some(path), the path must point to a directory, and classes will be saved into that directory.

Eval also supports a limited set of preprocessors. Currently, "limited" means "exactly one": directives of the form #include <file>.

The flow of evaluation is: - extract a string of code from the file, string, or input stream - run preprocessors on that string - wrap processed code in an apply method in a generated class - compile the class - contruct an instance of that class - return the result of apply()

Linear Supertypes

AnyRef, Any

Known Subclasses

Eval

Instance Constructors

new Eval()

empty constructor for backwards compatibility
new Eval(target: Option[File])

Type Members

class ClassScopedResolver extends Resolver
class CompilerException extends Exception
class FilesystemResolver extends Resolver
class IncludePreprocessor extends Preprocessor
trait Preprocessor extends AnyRef
class ResolutionFailedException extends Exception
trait Resolver extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
def apply[T](stream: InputStream): T

val i: Int = new Eval()(getClass.
val i: Int = new Eval()(getClass.getResourceAsStream("..."))
def apply[T](files: File*): T

val i: Int = new Eval()(new File(".
val i: Int = new Eval()(new File("..."))
def apply[T](code: String, resetState: Boolean = true): T

val i: Int = new Eval()("1 + 1") // => 2
def applyProcessed[T](className: String, code: String, resetState: Boolean): T

same as apply[T], but does not run preprocessors.
def applyProcessed[T](code: String, resetState: Boolean): T

same as apply[T], but does not run preprocessors.
same as apply[T], but does not run preprocessors. Will generate a classname of the form Evaluater<unique>, where unique is computed from the jvmID (a random number) and a digest of code
final def asInstanceOf[T0]: T0

Definition Classes
Any
def check(stream: InputStream): Unit

Check if stream is Eval-able.
Check if stream is Eval-able.

Exceptions thrown
CompilerException
if not Eval-able.
def check(files: File*): Unit

Check if files are Eval-able.
Check if files are Eval-able.

Exceptions thrown
CompilerException
if not Eval-able.
def check(code: String): Unit

Check if code is Eval-able.
Check if code is Eval-able.

Exceptions thrown
CompilerException
if not Eval-able.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def compile(code: String): Unit

Compile an entire source file into the virtual classloader.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws()
def findClass(className: String): Class[_]
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
lazy val impliedClassPath: List[String]
def inPlace[T](code: String): T

Like Eval(), but doesn't reset the virtual classloader before evaluating.
Like Eval(), but doesn't reset the virtual classloader before evaluating. So if you've loaded classes with compile, they can be referenced/imported in code run by inPlace.
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
lazy val preprocessors: Seq[Preprocessor]

Preprocessors to run the code through before it is passed to the Scala compiler.
Preprocessors to run the code through before it is passed to the Scala compiler. if you want to add new resolvers, you can do so with new Eval(...) { lazy val preprocessors = {...} }

Attributes
protected
def sourceForString(code: String): String

run preprocessors on our string, returning a String that is the processed source
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toSource(code: String): String

converts the given file to evaluable source.
def toSource(file: File): String

converts the given file to evaluable source.
converts the given file to evaluable source. delegates to toSource(code: String)
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws()
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws()
def writeChecksum(checksum: String, file: File): Unit

write the current checksum to a file

class Eval extends AnyRef

Instance Constructors

new Eval()

new Eval(target: Option[File])

Type Members

class ClassScopedResolver extends Resolver

class CompilerException extends Exception

class FilesystemResolver extends Resolver

class IncludePreprocessor extends Preprocessor

trait Preprocessor extends AnyRef

class ResolutionFailedException extends Exception

trait Resolver extends AnyRef

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def apply[T](stream: InputStream): T

def apply[T](files: File*): T

def apply[T](code: String, resetState: Boolean = true): T

def applyProcessed[T](className: String, code: String, resetState: Boolean): T

def applyProcessed[T](code: String, resetState: Boolean): T

final def asInstanceOf[T0]: T0

def check(stream: InputStream): Unit

def check(files: File*): Unit

def check(code: String): Unit

def clone(): AnyRef

def compile(code: String): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findClass(className: String): Class[_]

final def getClass(): Class[_]

def hashCode(): Int

lazy val impliedClassPath: List[String]

def inPlace[T](code: String): T

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

lazy val preprocessors: Seq[Preprocessor]

def sourceForString(code: String): String

final def synchronized[T0](arg0: ⇒ T0): T0

def toSource(code: String): String

def toSource(file: File): String

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def writeChecksum(checksum: String, file: File): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped