IntervalRDD

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: RDD[(K, V)]): RDD[(K, V)]

final def ==(arg0: Any): Boolean

def aggregate[U](zeroValue: U)(seqOp: (U, (K, V)) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

final def asInstanceOf[T0]: T0

def cache(): IntervalRDD.this.type

def cartesian[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((K, V), U)]

def checkpoint(): Unit

def clearDependencies(): Unit

def clone(): AnyRef

def coalesce(numPartitions: Int, shuffle: Boolean)(implicit ord: Ordering[(K, V)]): RDD[(K, V)]

def collect(interval: K): List[V]

Gets the values corresponding to the specified key, if any Assume that we're only getting data that exists (if it doesn't exist, would have been handled by upper LazyMaterialization layer

def collect(): Array[(K, V)]

def collect[U](f: PartialFunction[(K, V), U])(implicit arg0: ClassTag[U]): RDD[U]

def compute(part: Partition, context: TaskContext): Iterator[(K, V)]

Provides the RDD[(K, V)] equivalent output.

def context: SparkContext

def count(): Long

The number of elements in the RDD.

def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble]

def countApproxDistinct(relativeSD: Double): Long

def countApproxDistinct(p: Int, sp: Int): Long

def countByValue()(implicit ord: Ordering[(K, V)]): Map[(K, V), Long]

def countByValueApprox(timeout: Long, confidence: Double)(implicit ord: Ordering[(K, V)]): PartialResult[Map[(K, V), BoundedDouble]]

final def dependencies: Seq[Dependency[_]]

def distinct(): RDD[(K, V)]

def distinct(numPartitions: Int)(implicit ord: Ordering[(K, V)]): RDD[(K, V)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(pred: ((K, V)) ⇒ Boolean): IntervalRDD[K, V]

Performs filtering given a predicate

def filterByInterval(r: K): IntervalRDD[K, V]

def finalize(): Unit

def first(): (K, V)

def firstParent[U](implicit arg0: ClassTag[U]): RDD[U]

def flatMap[U](f: ((K, V)) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDD[U]

def fold(zeroValue: (K, V))(op: ((K, V), (K, V)) ⇒ (K, V)): (K, V)

def foreach(f: ((K, V)) ⇒ Unit): Unit

def foreachPartition(f: (Iterator[(K, V)]) ⇒ Unit): Unit

def getCheckpointFile: Option[String]

final def getClass(): Class[_]

def getDependencies: Seq[Dependency[_]]

final def getNumPartitions: Int

def getPartitions: Array[Partition]

def getPreferredLocations(split: Partition): Seq[String]

def getStorageLevel: StorageLevel

def glom(): RDD[Array[(K, V)]]

def groupBy[K](f: ((K, V)) ⇒ K, p: Partitioner)(implicit kt: ClassTag[K], ord: Ordering[K]): RDD[(K, Iterable[(K, V)])]

def groupBy[K](f: ((K, V)) ⇒ K, numPartitions: Int)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(K, V)])]

def groupBy[K](f: ((K, V)) ⇒ K)(implicit kt: ClassTag[K]): RDD[(K, Iterable[(K, V)])]

def hashCode(): Int

val id: Int

def intersection(other: RDD[(K, V)], numPartitions: Int): RDD[(K, V)]

def intersection(other: RDD[(K, V)], partitioner: Partitioner)(implicit ord: Ordering[(K, V)]): RDD[(K, V)]

def intersection(other: RDD[(K, V)]): RDD[(K, V)]

def isCheckpointed: Boolean

def isEmpty(): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

final def iterator(split: Partition, context: TaskContext): Iterator[(K, V)]

def keyBy[K](f: ((K, V)) ⇒ K): RDD[(K, (K, V))]

def localCheckpoint(): IntervalRDD.this.type

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 map[U](f: ((K, V)) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

def mapIntervalPartitions[K2 <: Interval[K2], V2](f: (IntervalPartition[K, V]) ⇒ IntervalPartition[K2, V2])(implicit arg0: ClassTag[K2], arg1: ClassTag[V2]): IntervalRDD[K2, V2]

Maps interval partitions in partitionsRDD

def mapPartitions[U](f: (Iterator[(K, V)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapPartitionsWithIndex[U](f: (Int, Iterator[(K, V)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapValues[V2](f: (V) ⇒ V2)(implicit arg0: ClassTag[V2]): IntervalRDD[K, V2]

Maps each value, preserving the index.

def max()(implicit ord: Ordering[(K, V)]): (K, V)

def min()(implicit ord: Ordering[(K, V)]): (K, V)

def multiput(elems: RDD[(K, V)]): IntervalRDD[K, V]

Unconditionally updates the specified keys to have the specified value.

def multiput(elem: (K, V)): IntervalRDD[K, V]

Unconditionally updates the specified keys to have the specified value.

def multiput(elems: Array[(K, V)]): IntervalRDD[K, V]

Unconditionally updates the specified keys to have the specified value.

var name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def parent[U](j: Int)(implicit arg0: ClassTag[U]): RDD[U]

val partitioner: Option[Partitioner]

final def partitions: Array[Partition]

def persist(newLevel: StorageLevel): IntervalRDD.this.type

Persists the interval partitions using targetStorageLevel, which defaults to MEMORY_ONLY.

def persist(): IntervalRDD.this.type

def pipe(command: Seq[String], env: Map[String, String], printPipeContext: ((String) ⇒ Unit) ⇒ Unit, printRDDElement: ((K, V), (String) ⇒ Unit) ⇒ Unit, separateWorkingDir: Boolean): RDD[String]

def pipe(command: String, env: Map[String, String]): RDD[String]

def pipe(command: String): RDD[String]

final def preferredLocations(split: Partition): Seq[String]

def randomSplit(weights: Array[Double], seed: Long): Array[RDD[(K, V)]]

def reduce(f: ((K, V), (K, V)) ⇒ (K, V)): (K, V)

def repartition(numPartitions: Int)(implicit ord: Ordering[(K, V)]): RDD[(K, V)]

def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDD[(K, V)]

def saveAsObjectFile(path: String): Unit

def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit

def saveAsTextFile(path: String): Unit

def setName(_name: String): IntervalRDD.this.type

def sortBy[K](f: ((K, V)) ⇒ K, ascending: Boolean, numPartitions: Int)(implicit ord: Ordering[K], ctag: ClassTag[K]): RDD[(K, V)]

def sparkContext: SparkContext

def subtract(other: RDD[(K, V)], p: Partitioner)(implicit ord: Ordering[(K, V)]): RDD[(K, V)]

def subtract(other: RDD[(K, V)], numPartitions: Int): RDD[(K, V)]

def subtract(other: RDD[(K, V)]): RDD[(K, V)]

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

def take(num: Int): Array[(K, V)]

def takeOrdered(num: Int)(implicit ord: Ordering[(K, V)]): Array[(K, V)]

def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[(K, V)]

def toDebugString: String

def toJavaRDD(): JavaRDD[(K, V)]

def toLocalIterator: Iterator[(K, V)]

def toRDD: RDD[(K, V)]

def toString(): String

def top(num: Int)(implicit ord: Ordering[(K, V)]): Array[(K, V)]

def treeAggregate[U](zeroValue: U)(seqOp: (U, (K, V)) ⇒ U, combOp: (U, U) ⇒ U, depth: Int)(implicit arg0: ClassTag[U]): U

def treeReduce(f: ((K, V), (K, V)) ⇒ (K, V), depth: Int): (K, V)

def union(other: RDD[(K, V)]): RDD[(K, V)]

def unpersist(blocking: Boolean = true): IntervalRDD.this.type

Unpersists the interval partitions using

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def zip[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((K, V), U)]

def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D])(f: (Iterator[(K, V)], Iterator[B], Iterator[C], Iterator[D]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[D], arg3: ClassTag[V]): RDD[V]

def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D], preservesPartitioning: Boolean)(f: (Iterator[(K, V)], Iterator[B], Iterator[C], Iterator[D]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[D], arg3: ClassTag[V]): RDD[V]

def zipPartitions[B, C, V](rdd2: RDD[B], rdd3: RDD[C])(f: (Iterator[(K, V)], Iterator[B], Iterator[C]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[V]): RDD[V]

def zipPartitions[B, C, V](rdd2: RDD[B], rdd3: RDD[C], preservesPartitioning: Boolean)(f: (Iterator[(K, V)], Iterator[B], Iterator[C]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[C], arg2: ClassTag[V]): RDD[V]

def zipPartitions[B, V](rdd2: RDD[B])(f: (Iterator[(K, V)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

def zipPartitions[B, V](rdd2: RDD[B], preservesPartitioning: Boolean)(f: (Iterator[(K, V)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

def zipWithIndex(): RDD[((K, V), Long)]

def zipWithUniqueId(): RDD[((K, V), Long)]

def filterWith[A](constructA: (Int) ⇒ A)(p: ((K, V), A) ⇒ Boolean): RDD[(K, V)]

def flatMapWith[A, U](constructA: (Int) ⇒ A, preservesPartitioning: Boolean)(f: ((K, V), A) ⇒ Seq[U])(implicit arg0: ClassTag[U]): RDD[U]

def foreachWith[A](constructA: (Int) ⇒ A)(f: ((K, V), A) ⇒ Unit): Unit

def mapPartitionsWithContext[U](f: (TaskContext, Iterator[(K, V)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapPartitionsWithSplit[U](f: (Int, Iterator[(K, V)]) ⇒ Iterator[U], preservesPartitioning: Boolean)(implicit arg0: ClassTag[U]): RDD[U]

def mapWith[A, U](constructA: (Int) ⇒ A, preservesPartitioning: Boolean)(f: ((K, V), A) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

def toArray(): Array[(K, V)]