ScexPresentationCompiler

abstract val settings: ScexSettings

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compile(sourceFile: ScexSourceFile): Either[ScexClassLoader, List[CompileError]]

def compileClass(code: String, name: String): Class[_]

Compiles arbitrary Scala source file into a dedicated class loader and loads class with given fully qualified name from that class loader.

def compileExpression(exprDef: ExpressionDef): Try[RawExpression]

def compileExpressionUtils(utils: NamedSource): Try[Option[String]]

def compileJavaGetterAdapters(name: String, classes: Seq[Class[_]], full: Boolean): Try[Seq[Option[String]]]

def compileProfileObject(profile: ExpressionProfile): Try[Option[String]]

def compileSymbolAttributes(source: NamedSource): SymbolAttributes

def compileSymbolValidator(source: NamedSource): SymbolValidator

def compileSyntaxValidator(source: NamedSource): SyntaxValidator

def createLogger[T](implicit arg0: ClassTag[T]): LazyLogger

def createNonSharedClassLoader(sourceFile: ScexSourceFile): ScexClassLoader

final def ensureSetup(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

final def expressionCode(exprDef: ExpressionDef, noMacroProcessing: Boolean = false): (String, String, Int)

def finalize(): Unit

final def getClass(): Class[_]

def getCompiledExpression[C <: ExpressionContext[_, _], T](profile: ExpressionProfile, expression: String, variableTypes: Map[String, scala.reflect.api.JavaUniverse.Type] = Map.empty, template: Boolean = true, header: String = "")(implicit ctt: scala.reflect.api.JavaUniverse.TypeTag[C], ttt: scala.reflect.api.JavaUniverse.TypeTag[T]): Expression[C, T]

final def getCompiledExpression[C <: ExpressionContext[_, _], T](exprDef: ExpressionDef): Expression[C, T]

def getCompiledSetterExpression[C <: ExpressionContext[_, _], T](profile: ExpressionProfile, expression: String, template: Boolean = true, variableTypes: Map[String, scala.reflect.api.JavaUniverse.Type] = Map.empty, header: String = "")(implicit ctt: scala.reflect.api.JavaUniverse.TypeTag[C], ttt: scala.reflect.api.JavaUniverse.TypeTag[T]): Expression[C, Setter[T]]

def getCompleter(profile: ExpressionProfile, template: Boolean, setter: Boolean, header: String, contextType: String, rootObjectClass: Class[_], resultType: String, variableTypes: Map[String, String]): Completer

def getCompleter[C <: ExpressionContext[_, _], T](profile: ExpressionProfile, template: Boolean = true, setter: Boolean = false, variableTypes: Map[String, scala.reflect.api.JavaUniverse.Type] = Map.empty, header: String = "")(implicit ctt: scala.reflect.api.JavaUniverse.TypeTag[C], ttt: scala.reflect.api.JavaUniverse.TypeTag[T]): Completer

def getErrors(exprDef: ExpressionDef): List[CompileError]

def getOrThrow[T](resp: Response[T]): T

def getScopeCompletion(exprDef: ExpressionDef): Completion

def getSharedClassLoader: ScexClassLoader

def getTypeCompletion(exprDef: ExpressionDef, position: Int): Completion

def getTypeMembers(global: IGlobal)(exprDef: ExpressionDef, ownerTpe: IGlobal.Type)(computeMembers: ⇒ Vector[Member]): Vector[Member]

def hashCode(): Int

def instantiate[T](classLoader: ClassLoader, className: String): T

def isEnabled: Boolean

final def isInstanceOf[T0]: Boolean

def loadCompilerPlugins(global: ScexGlobal): List[Plugin]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parse(exprDef: ExpressionDef): Tree

def preprocess(expression: String, template: Boolean): (String, PositionMapping)

def reset(): Unit

Resets internal compiler state by creating completely new instance of Scala compiler and invalidating all internal caches.

def runCompiler(global: ScexGlobal, sourceFile: ScexSourceFile): Unit

def setup(): Unit

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

def toString(): String

def underLock[T](code: ⇒ T): T

final def wait(): Unit

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

final def wait(arg0: Long): Unit

final def withGlobal[T](code: (ScexGlobal) ⇒ T): T

final def withIGlobal[T](code: (IGlobal) ⇒ T): T