AdStaxSparkContext

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addFile(path: String, recursive: Boolean): Unit

def addFile(path: String): Unit

def addJar(path: String): Unit

def addSparkListener(listener: SparkListenerInterface): Unit

def appName: String

def applicationAttemptId: Option[String]

def applicationId: String

final def asInstanceOf[T0]: T0

def binaryFiles(path: String, minPartitions: Int): RDD[(String, PortableDataStream)]

def binaryRecords(path: String, recordLength: Int, conf: Configuration): RDD[Array[Byte]]

def broadcast[T](value: T)(implicit arg0: ClassTag[T]): Broadcast[T]

def cancelAllJobs(): Unit

def cancelJob(jobId: Int): Unit

def cancelJobGroup(groupId: String): Unit

def cancelStage(stageId: Int): Unit

def checkpointFile[T](path: String)(implicit arg0: ClassTag[T]): RDD[T]

def clearCallSite(): Unit

def clearJobGroup(): Unit

def clone(): AnyRef

def collectionAccumulator[T](name: String): CollectionAccumulator[T]

def collectionAccumulator[T]: CollectionAccumulator[T]

def defaultMinPartitions: Int

def defaultParallelism: Int

def deployMode: String

def doubleAccumulator(name: String): DoubleAccumulator

def doubleAccumulator: DoubleAccumulator

def emptyRDD[T](implicit arg0: ClassTag[T]): RDD[T]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def eventsRDD(eventTypes: Set[String], startDateTime: com.github.nscala_time.time.Imports.DateTime, endDateTime: com.github.nscala_time.time.Imports.DateTime): RDD[String]

Returns all AdStax events between startDateTime and endDateTime which have a type contained in eventTypes.

def files: Seq[String]

def finalize(): Unit

def getAllPools: Seq[Schedulable]

def getCheckpointDir: Option[String]

final def getClass(): Class[_]

def getConf: SparkConf

def getExecutorMemoryStatus: Map[String, (Long, Long)]

def getExecutorStorageStatus: Array[StorageStatus]

def getLocalProperty(key: String): String

def getPersistentRDDs: Map[Int, RDD[_]]

def getPoolForName(pool: String): Option[Schedulable]

def getRDDStorageInfo: Array[RDDInfo]

def getSchedulingMode: SchedulingMode

def hadoopConfiguration: Configuration

def hadoopFile[K, V, F <: InputFormat[K, V]](path: String)(implicit km: ClassTag[K], vm: ClassTag[V], fm: ClassTag[F]): RDD[(K, V)]

def hadoopFile[K, V, F <: InputFormat[K, V]](path: String, minPartitions: Int)(implicit km: ClassTag[K], vm: ClassTag[V], fm: ClassTag[F]): RDD[(K, V)]

def hadoopFile[K, V](path: String, inputFormatClass: Class[_ <: InputFormat[K, V]], keyClass: Class[K], valueClass: Class[V], minPartitions: Int): RDD[(K, V)]

def hadoopRDD[K, V](conf: JobConf, inputFormatClass: Class[_ <: InputFormat[K, V]], keyClass: Class[K], valueClass: Class[V], minPartitions: Int): RDD[(K, V)]

def hashCode(): Int

def initializeLogIfNecessary(isInterpreter: Boolean): Unit

final def isInstanceOf[T0]: Boolean

def isLocal: Boolean

def isStopped: Boolean

def isTraceEnabled(): Boolean

def jars: Seq[String]

def killExecutor(executorId: String): Boolean

def killExecutors(executorIds: Seq[String]): Boolean

def listFiles(): Seq[String]

def listJars(): Seq[String]

val localProperties: InheritableThreadLocal[Properties]

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 logName: String

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 longAccumulator(name: String): LongAccumulator

def longAccumulator: LongAccumulator

def makeRDD[T](seq: Seq[(T, Seq[String])])(implicit arg0: ClassTag[T]): RDD[T]

def makeRDD[T](seq: Seq[T], numSlices: Int)(implicit arg0: ClassTag[T]): RDD[T]

def master: String

final def ne(arg0: AnyRef): Boolean

def newAPIHadoopFile[K, V, F <: InputFormat[K, V]](path: String, fClass: Class[F], kClass: Class[K], vClass: Class[V], conf: Configuration): RDD[(K, V)]

def newAPIHadoopFile[K, V, F <: InputFormat[K, V]](path: String)(implicit km: ClassTag[K], vm: ClassTag[V], fm: ClassTag[F]): RDD[(K, V)]

def newAPIHadoopRDD[K, V, F <: InputFormat[K, V]](conf: Configuration, fClass: Class[F], kClass: Class[K], vClass: Class[V]): RDD[(K, V)]

final def notify(): Unit

final def notifyAll(): Unit

def objectFile[T](path: String, minPartitions: Int)(implicit arg0: ClassTag[T]): RDD[T]

def parallelize[T](seq: Seq[T], numSlices: Int)(implicit arg0: ClassTag[T]): RDD[T]

def range(start: Long, end: Long, step: Long, numSlices: Int): RDD[Long]

def register(acc: AccumulatorV2[_, _], name: String): Unit

def register(acc: AccumulatorV2[_, _]): Unit

def requestExecutors(numAdditionalExecutors: Int): Boolean

def requestTotalExecutors(numExecutors: Int, localityAwareTasks: Int, hostToLocalTaskCount: Map[String, Int]): Boolean

def runApproximateJob[T, U, R](rdd: RDD[T], func: (TaskContext, Iterator[T]) ⇒ U, evaluator: ApproximateEvaluator[U, R], timeout: Long): PartialResult[R]

def runJob[T, U](rdd: RDD[T], processPartition: (Iterator[T]) ⇒ U, resultHandler: (Int, U) ⇒ Unit)(implicit arg0: ClassTag[U]): Unit

def runJob[T, U](rdd: RDD[T], processPartition: (TaskContext, Iterator[T]) ⇒ U, resultHandler: (Int, U) ⇒ Unit)(implicit arg0: ClassTag[U]): Unit

def runJob[T, U](rdd: RDD[T], func: (Iterator[T]) ⇒ U)(implicit arg0: ClassTag[U]): Array[U]

def runJob[T, U](rdd: RDD[T], func: (TaskContext, Iterator[T]) ⇒ U)(implicit arg0: ClassTag[U]): Array[U]

def runJob[T, U](rdd: RDD[T], func: (Iterator[T]) ⇒ U, partitions: Seq[Int])(implicit arg0: ClassTag[U]): Array[U]

def runJob[T, U](rdd: RDD[T], func: (TaskContext, Iterator[T]) ⇒ U, partitions: Seq[Int])(implicit arg0: ClassTag[U]): Array[U]

def runJob[T, U](rdd: RDD[T], func: (TaskContext, Iterator[T]) ⇒ U, partitions: Seq[Int], resultHandler: (Int, U) ⇒ Unit)(implicit arg0: ClassTag[U]): Unit

def sequenceFile[K, V](path: String, minPartitions: Int)(implicit km: ClassTag[K], vm: ClassTag[V], kcf: () ⇒ WritableConverter[K], vcf: () ⇒ WritableConverter[V]): RDD[(K, V)]

def sequenceFile[K, V](path: String, keyClass: Class[K], valueClass: Class[V]): RDD[(K, V)]

def sequenceFile[K, V](path: String, keyClass: Class[K], valueClass: Class[V], minPartitions: Int): RDD[(K, V)]

def setCallSite(shortCallSite: String): Unit

def setCheckpointDir(directory: String): Unit

def setJobDescription(value: String): Unit

def setJobGroup(groupId: String, description: String, interruptOnCancel: Boolean): Unit

def setLocalProperty(key: String, value: String): Unit

def setLogLevel(logLevel: String): Unit

val sparkUser: String

val startTime: Long

def statusTracker: SparkStatusTracker

def stop(): Unit

def submitJob[T, U, R](rdd: RDD[T], processPartition: (Iterator[T]) ⇒ U, partitions: Seq[Int], resultHandler: (Int, U) ⇒ Unit, resultFunc: ⇒ R): SimpleFutureAction[R]

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

def textFile(path: String, minPartitions: Int): RDD[String]

def toString(): String

def uiWebUrl: Option[String]

def union[T](first: RDD[T], rest: RDD[T]*)(implicit arg0: ClassTag[T]): RDD[T]

def union[T](rdds: Seq[RDD[T]])(implicit arg0: ClassTag[T]): RDD[T]

def version: String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wholeTextFiles(path: String, minPartitions: Int): RDD[(String, String)]

def accumulable[R, T](initialValue: R, name: String)(implicit param: AccumulableParam[R, T]): Accumulable[R, T]

def accumulable[R, T](initialValue: R)(implicit param: AccumulableParam[R, T]): Accumulable[R, T]

def accumulableCollection[R, T](initialValue: R)(implicit arg0: (R) ⇒ Growable[T] with TraversableOnce[T] with Serializable, arg1: ClassTag[R]): Accumulable[R, T]

def accumulator[T](initialValue: T, name: String)(implicit param: AccumulatorParam[T]): Accumulator[T]

def accumulator[T](initialValue: T)(implicit param: AccumulatorParam[T]): Accumulator[T]