SparkILoop

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addClasspath(arg: String): Unit

def addReplay(cmd: String): Unit

Record a command for replay should the user request a :replay

var addedClasspath: String

final def asInstanceOf[T0]: T0

def chooseReader(settings: Settings): InteractiveReader

Tries to create a JLineReader, falling back to SimpleReader: unless settings or properties are such that it should start with SimpleReader.

def clone(): AnyRef

def closeInterpreter(): Unit

Close the interpreter and set the var to null.

def command(line: String): Result

Run one command submitted by the user.

def commands: List[LoopCommand]

Available commands

def createInterpreter(): Unit

Create a new interpreter.

def createSparkContext(): SparkContext

def echoCommandMessage(msg: String): Unit

def enablePowerMode(): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): java.lang.Class[_]

def hashCode(): Int

def helpCommand(line: String): Result

print a friendly help message

def history: History

lazy val historyCommand: LoopCommand { def defaultLines: Int }

Show the history

var in: InteractiveReader

def initLogging(): Unit

def initializeSpark(): Unit

def interpretAllFrom(file: File): Unit

interpret all lines from a specified file

def interpretStartingWith(code: String): Option[String]

Interpret expressions starting with the first line.

var intp: SparkIMain

final def isInstanceOf[T0]: Boolean

def loadCommand(arg: String): Result

def loadFiles(settings: Settings): Unit

def log: Logger

def logDebug(msg: ⇒ String, throwable: Throwable): Unit

def logDebug(msg: ⇒ String): Unit

def logError(msg: ⇒ String, throwable: Throwable): Unit

def logError(msg: ⇒ String): Unit

def logInfo(msg: ⇒ String, throwable: Throwable): Unit

def logInfo(msg: ⇒ String): Unit

def logTrace(msg: ⇒ String, throwable: Throwable): Unit

def logTrace(msg: ⇒ String): Unit

def logWarning(msg: ⇒ String, throwable: Throwable): Unit

def logWarning(msg: ⇒ String): Unit

def loop(): Unit

The main read-eval-print loop for the repl.

val master: Option[String]

final def ne(arg0: AnyRef): Boolean

def newJavap(): Javap

final def notify(): Unit

final def notifyAll(): Unit

val originalClassLoader: ClassLoader

The context class loader at the time this object was created

val out: PrintWriter

def pasteCommand(): Result

def powerCmd(): Result

lazy val powerCommands: List[LoopCommand]

Power user commands

def printWelcome(): Unit

Print a welcome message

def process(args: Array[String]): Boolean

process command-line arguments and do as they request

def process(settings: Settings): Boolean

def prompt: String

Prompt to print when awaiting input

def replay(): Unit

create a new interpreter and replay all commands so far

var replayCommandStack: List[String]

A reverse list of commands to replay if the user requests a :replay

def replayCommands: List[String]

A list of commands to replay if the user requests a :replay

val replayQuestionMessage: String

def searchHistory(_cmdline: String): Unit

Search the history

def setPrompt(prompt: String): Unit

var settings: Settings

lazy val shCommand: LoopCommand

fork a shell and run a command

var sparkContext: SparkContext

lazy val standardCommands: List[LoopCommand]

Standard commands *

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

def toString(): String

def verbosity(): Unit

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFile(filename: String)(action: (File) ⇒ Unit): Unit

def interpreter: SparkIMain

def interpreter_=(i: SparkIMain): Unit

def main(settings: Settings): Unit

def main(args: Array[String]): Unit