in compiler/frontend/spark/src/main/scala/org/apache/nemo/compiler/frontend/spark/core/rdd/RDD.scala [321:599]
override def persist(): RDD.this.type = persist(StorageLevel.MEMORY_ONLY)
/**
* Persist this RDD with the default storage level (`MEMORY_ONLY`).
*/
override def cache(): RDD.this.type = persist()
/////////////// UNSUPPORTED METHODS ///////////////
//TODO#92: Implement the unimplemented transformations/actions & dataset initialization methods for Spark frontend.
override protected def getDependencies: Seq[Dependency[_]] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override protected def getPreferredLocations(split: Partition): Seq[String] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def sparkContext: SparkContext = super.sparkContext
override def setName(_name: String): RDD.this.type =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def unpersist(blocking: Boolean): RDD.this.type =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def getStorageLevel: StorageLevel =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def filter(f: (T) => Boolean): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def distinct(numPartitions: Int)(implicit ord: Ordering[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def distinct(): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def repartition(numPartitions: Int)(implicit ord: Ordering[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def coalesce(numPartitions: Int, shuffle: Boolean, partitionCoalescer: Option[PartitionCoalescer])
(implicit ord: Ordering[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def randomSplit(weights: Array[Double], seed: Long): Array[org.apache.spark.rdd.RDD[T]] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def union(other: org.apache.spark.rdd.RDD[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def ++(other: org.apache.spark.rdd.RDD[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def sortBy[K](f: (T) => K, ascending: Boolean, numPartitions: Int)
(implicit ord: Ordering[K], ctag: ClassManifest[K]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def intersection(other: org.apache.spark.rdd.RDD[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def intersection(other: org.apache.spark.rdd.RDD[T], partitioner: Partitioner)
(implicit ord: Ordering[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def intersection(other: org.apache.spark.rdd.RDD[T], numPartitions: Int): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def glom(): RDD[Array[T]] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def cartesian[U](other: org.apache.spark.rdd.RDD[U])(implicit evidence$5: ClassManifest[U]): RDD[(T, U)] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def groupBy[K](f: (T) => K)(implicit kt: ClassManifest[K]): RDD[(K, Iterable[T])] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def groupBy[K](f: (T) => K, numPartitions: Int)(implicit kt: ClassManifest[K]): RDD[(K, Iterable[T])] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def groupBy[K](f: (T) => K, p: Partitioner)
(implicit kt: ClassManifest[K], ord: Ordering[K]): RDD[(K, Iterable[T])] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def pipe(command: String): RDD[String] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def pipe(command: String, env: scala.collection.Map[String, String]): RDD[String] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def pipe(command: Seq[String], env: scala.collection.Map[String, String],
printPipeContext: ((String) => Unit) => Unit,
printRDDElement: (T, (String) => Unit) => Unit, separateWorkingDir: Boolean,
bufferSize: Int, encoding: String): RDD[String] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def mapPartitions[U](f: (Iterator[T]) => Iterator[U], preservesPartitioning: Boolean)
(implicit evidence$6: ClassManifest[U]): RDD[U] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def mapPartitionsWithIndex[U](f: (Int, Iterator[T]) => Iterator[U], preservesPartitioning: Boolean)
(implicit evidence$9: ClassManifest[U]): RDD[U] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zip[U](other: org.apache.spark.rdd.RDD[U])(implicit evidence$10: ClassManifest[U]): RDD[(T, U)] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipPartitions[B, V](rdd2: org.apache.spark.rdd.RDD[B], preservesPartitioning: Boolean)
(f: (Iterator[T], Iterator[B]) => Iterator[V])
(implicit evidence$11: ClassManifest[B], evidence$12: ClassManifest[V]): RDD[V] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipPartitions[B, V](rdd2: org.apache.spark.rdd.RDD[B])(f: (Iterator[T], Iterator[B]) => Iterator[V])
(implicit evidence$13: ClassManifest[B], evidence$14: ClassManifest[V]): RDD[V] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipPartitions[B, C, V](rdd2: org.apache.spark.rdd.RDD[B],
rdd3: org.apache.spark.rdd.RDD[C], preservesPartitioning: Boolean)
(f: (Iterator[T], Iterator[B], Iterator[C]) => Iterator[V])
(implicit evidence$15: ClassManifest[B], evidence$16: ClassManifest[C],
evidence$17: ClassManifest[V]): RDD[V] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipPartitions[B, C, V](rdd2: org.apache.spark.rdd.RDD[B],
rdd3: org.apache.spark.rdd.RDD[C])
(f: (Iterator[T], Iterator[B], Iterator[C]) => Iterator[V])
(implicit evidence$18: ClassManifest[B], evidence$19: ClassManifest[C],
evidence$20: ClassManifest[V]): RDD[V] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipPartitions[B, C, D, V](rdd2: org.apache.spark.rdd.RDD[B],
rdd3: org.apache.spark.rdd.RDD[C],
rdd4: org.apache.spark.rdd.RDD[D], preservesPartitioning: Boolean)
(f: (Iterator[T], Iterator[B], Iterator[C], Iterator[D]) => Iterator[V])
(implicit evidence$21: ClassManifest[B], evidence$22: ClassManifest[C],
evidence$23: ClassManifest[D], evidence$24: ClassManifest[V]): RDD[V] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipPartitions[B, C, D, V](rdd2: org.apache.spark.rdd.RDD[B],
rdd3: org.apache.spark.rdd.RDD[C],
rdd4: org.apache.spark.rdd.RDD[D])
(f: (Iterator[T], Iterator[B], Iterator[C], Iterator[D]) => Iterator[V])
(implicit evidence$25: ClassManifest[B], evidence$26: ClassManifest[C],
evidence$27: ClassManifest[D], evidence$28: ClassManifest[V]): RDD[V] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def foreach(f: (T) => Unit): Unit =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def foreachPartition(f: (Iterator[T]) => Unit): Unit =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def toLocalIterator: Iterator[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def collect[U](f: PartialFunction[T, U])(implicit evidence$29: ClassManifest[U]): RDD[U] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def subtract(other: org.apache.spark.rdd.RDD[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def subtract(other: org.apache.spark.rdd.RDD[T], numPartitions: Int): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def subtract(other: org.apache.spark.rdd.RDD[T], p: Partitioner)(implicit ord: Ordering[T]): RDD[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def treeReduce(f: (T, T) => T, depth: Int): T =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def fold(zeroValue: T)(op: (T, T) => T): T =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def aggregate[U](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U)
(implicit evidence$30: ClassManifest[U]): U =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def treeAggregate[U](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U, depth: Int)
(implicit evidence$31: ClassManifest[U]): U =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def count(): Long =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def countByValue()(implicit ord: Ordering[T]): Map[T, Long] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def countByValueApprox(timeout: Long, confidence: Double)
(implicit ord: Ordering[T]): PartialResult[scala.collection.Map[T, BoundedDouble]] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def countApproxDistinct(p: Int, sp: Int): Long =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def countApproxDistinct(relativeSD: Double): Long =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipWithIndex(): RDD[(T, Long)] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def zipWithUniqueId(): RDD[(T, Long)] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def take(num: Int): Array[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def first(): T =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def top(num: Int)(implicit ord: Ordering[T]): Array[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def takeOrdered(num: Int)(implicit ord: Ordering[T]): Array[T] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def max()(implicit ord: Ordering[T]): T =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def min()(implicit ord: Ordering[T]): T =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def isEmpty(): Boolean =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def saveAsTextFile(path: String, codec: Class[_ <: CompressionCodec]): Unit =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def saveAsObjectFile(path: String): Unit =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def keyBy[K](f: (T) => K): RDD[(K, T)] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def checkpoint(): Unit =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def localCheckpoint(): RDD.this.type =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def isCheckpointed: Boolean =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def getCheckpointFile: Option[String] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def firstParent[U](implicit evidence$32: ClassManifest[U]): RDD[U] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def parent[U](j: Int)(implicit evidence$33: ClassManifest[U]): RDD[U] =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def context: SparkContext =
throw new UnsupportedOperationException("Operation not yet implemented.")
override protected def clearDependencies(): Unit =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def toDebugString: String =
throw new UnsupportedOperationException("Operation not yet implemented.")
override def toString(): String =
throw new UnsupportedOperationException("Operation not yet implemented.")
}
/**
* Defines implicit functions that provide extra functionalities on RDDs of specific types.
*
* For example, [[RDD.rddToPairRDDFunctions]] converts an RDD into a [[PairRDDFunctions]] for
* key-value-pair RDDs, and enabling extra functionalities such as `PairRDDFunctions.reduceByKey`.
*/
object RDD {