VertexRDDImpl

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(other: RDD[(VertexId, VD)]): RDD[(VertexId, VD)]

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

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

def aggregateUsingIndex[VD2](messages: RDD[(VertexId, VD2)], reduceFunc: (VD2, VD2) ⇒ VD2)(implicit arg0: ClassTag[VD2]): VertexRDD[VD2]

Aggregates vertices in messages that have the same ids using reduceFunc, returning a VertexRDD co-indexed with this.

final def asInstanceOf[T0]: T0

def cache(): VertexRDDImpl.this.type

Persists the vertex partitions at targetStorageLevel, which defaults to MEMORY_ONLY.

def cartesian[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((VertexId, VD), U)]

def checkpoint(): Unit

def clearDependencies(): Unit

def clone(): AnyRef

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

def collect[U](f: PartialFunction[(VertexId, VD), U])(implicit arg0: ClassTag[U]): RDD[U]

def collect(): Array[(VertexId, VD)]

def compute(part: Partition, context: TaskContext): Iterator[(VertexId, VD)]

Provides the RDD[(VertexId, VD)] equivalent output.

def context: SparkContext

def count(): Long

The number of vertices 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[(VertexId, VD)]): Map[(VertexId, VD), Long]

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

final def dependencies: Seq[Dependency[_]]

def diff(other: VertexRDD[VD]): VertexRDD[VD]

For each vertex present in both this and other, diff returns only those vertices with differing values; for values that are different, keeps the values from other.

def diff(other: RDD[(VertexId, VD)]): VertexRDD[VD]

For each vertex present in both this and other, diff returns only those vertices with differing values; for values that are different, keeps the values from other.

def distinct(): RDD[(VertexId, VD)]

def distinct(numPartitions: Int)(implicit ord: Ordering[(VertexId, VD)]): RDD[(VertexId, VD)]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def filter(pred: ((VertexId, VD)) ⇒ Boolean): VertexRDD[VD]

Restricts the vertex set to the set of vertices satisfying the given predicate.

def finalize(): Unit

def first(): (VertexId, VD)

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

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

def fold(zeroValue: (VertexId, VD))(op: ((VertexId, VD), (VertexId, VD)) ⇒ (VertexId, VD)): (VertexId, VD)

def foreach(f: ((VertexId, VD)) ⇒ Unit): Unit

def foreachPartition(f: (Iterator[(VertexId, VD)]) ⇒ Unit): Unit

def getCheckpointFile: Option[String]

final def getClass(): Class[_]

def getDependencies: Seq[Dependency[_]]

def getPartitions: Array[Partition]

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

def getStorageLevel: StorageLevel

def glom(): RDD[Array[(VertexId, VD)]]

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

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

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

def hashCode(): Int

val id: Int

def innerJoin[U, VD2](other: RDD[(VertexId, U)])(f: (VertexId, VD, U) ⇒ VD2)(implicit arg0: ClassTag[U], arg1: ClassTag[VD2]): VertexRDD[VD2]

Inner joins this VertexRDD with an RDD containing vertex attribute pairs.

def innerZipJoin[U, VD2](other: VertexRDD[U])(f: (VertexId, VD, U) ⇒ VD2)(implicit arg0: ClassTag[U], arg1: ClassTag[VD2]): VertexRDD[VD2]

Efficiently inner joins this VertexRDD with another VertexRDD sharing the same index.

def intersection(other: RDD[(VertexId, VD)], numPartitions: Int): RDD[(VertexId, VD)]

def intersection(other: RDD[(VertexId, VD)], partitioner: Partitioner)(implicit ord: Ordering[(VertexId, VD)]): RDD[(VertexId, VD)]

def intersection(other: RDD[(VertexId, VD)]): RDD[(VertexId, VD)]

def isCheckpointed: Boolean

def isEmpty(): Boolean

final def isInstanceOf[T0]: Boolean

def isTraceEnabled(): Boolean

final def iterator(split: Partition, context: TaskContext): Iterator[(VertexId, VD)]

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

def leftJoin[VD2, VD3](other: RDD[(VertexId, VD2)])(f: (VertexId, VD, Option[VD2]) ⇒ VD3)(implicit arg0: ClassTag[VD2], arg1: ClassTag[VD3]): VertexRDD[VD3]

Left joins this VertexRDD with an RDD containing vertex attribute pairs.

def leftZipJoin[VD2, VD3](other: VertexRDD[VD2])(f: (VertexId, VD, Option[VD2]) ⇒ VD3)(implicit arg0: ClassTag[VD2], arg1: ClassTag[VD3]): VertexRDD[VD3]

Left joins this RDD with another VertexRDD with the same index.

def localCheckpoint(): VertexRDDImpl.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: ((VertexId, VD)) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

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

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

def mapValues[VD2](f: (VertexId, VD) ⇒ VD2)(implicit arg0: ClassTag[VD2]): VertexRDD[VD2]

Maps each vertex attribute, additionally supplying the vertex ID.

def mapValues[VD2](f: (VD) ⇒ VD2)(implicit arg0: ClassTag[VD2]): VertexRDD[VD2]

Maps each vertex attribute, preserving the index.

def max()(implicit ord: Ordering[(VertexId, VD)]): (VertexId, VD)

def min()(implicit ord: Ordering[(VertexId, VD)]): (VertexId, VD)

def minus(other: VertexRDD[VD]): VertexRDD[VD]

For each VertexId present in both this and other, minus will act as a set difference operation returning only those unique VertexId's present in this.

def minus(other: RDD[(VertexId, VD)]): VertexRDD[VD]

For each VertexId present in both this and other, minus will act as a set difference operation returning only those unique VertexId's present in this.

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]

val partitionsRDD: RDD[ShippableVertexPartition[VD]]

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

Persists the vertex partitions at the specified storage level, ignoring any existing target storage level.

def persist(): VertexRDDImpl.this.type

def pipe(command: Seq[String], env: Map[String, String], printPipeContext: ((String) ⇒ Unit) ⇒ Unit, printRDDElement: ((VertexId, VD), (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[(VertexId, VD)]]

def reduce(f: ((VertexId, VD), (VertexId, VD)) ⇒ (VertexId, VD)): (VertexId, VD)

def reindex(): VertexRDD[VD]

Construct a new VertexRDD that is indexed by only the visible vertices.

def repartition(numPartitions: Int)(implicit ord: Ordering[(VertexId, VD)]): RDD[(VertexId, VD)]

def reverseRoutingTables(): VertexRDD[VD]

Returns a new VertexRDD reflecting a reversal of all edge directions in the corresponding EdgeRDD.

def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDD[(VertexId, VD)]

def saveAsObjectFile(path: String): Unit

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

def saveAsTextFile(path: String): Unit

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

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

def sparkContext: SparkContext

def subtract(other: RDD[(VertexId, VD)], p: Partitioner)(implicit ord: Ordering[(VertexId, VD)]): RDD[(VertexId, VD)]

def subtract(other: RDD[(VertexId, VD)], numPartitions: Int): RDD[(VertexId, VD)]

def subtract(other: RDD[(VertexId, VD)]): RDD[(VertexId, VD)]

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

def take(num: Int): Array[(VertexId, VD)]

def takeOrdered(num: Int)(implicit ord: Ordering[(VertexId, VD)]): Array[(VertexId, VD)]

def takeSample(withReplacement: Boolean, num: Int, seed: Long): Array[(VertexId, VD)]

val targetStorageLevel: StorageLevel

def toDebugString: String

def toJavaRDD(): JavaRDD[(VertexId, VD)]

def toLocalIterator: Iterator[(VertexId, VD)]

def toString(): String

def top(num: Int)(implicit ord: Ordering[(VertexId, VD)]): Array[(VertexId, VD)]

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

def treeReduce(f: ((VertexId, VD), (VertexId, VD)) ⇒ (VertexId, VD), depth: Int): (VertexId, VD)

def union(other: RDD[(VertexId, VD)]): RDD[(VertexId, VD)]

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

implicit val vdTag: ClassTag[VD]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withEdges(edges: EdgeRDD[_]): VertexRDD[VD]

Prepares this VertexRDD for efficient joins with the given EdgeRDD.

def zip[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((VertexId, VD), U)]

def zipPartitions[B, C, D, V](rdd2: RDD[B], rdd3: RDD[C], rdd4: RDD[D])(f: (Iterator[(VertexId, VD)], 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[(VertexId, VD)], 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[(VertexId, VD)], 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[(VertexId, VD)], 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[(VertexId, VD)], Iterator[B]) ⇒ Iterator[V])(implicit arg0: ClassTag[B], arg1: ClassTag[V]): RDD[V]

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

def zipWithIndex(): RDD[((VertexId, VD), Long)]

def zipWithUniqueId(): RDD[((VertexId, VD), Long)]

def filterWith[A](constructA: (Int) ⇒ A)(p: ((VertexId, VD), A) ⇒ Boolean): RDD[(VertexId, VD)]

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

def foreachWith[A](constructA: (Int) ⇒ A)(f: ((VertexId, VD), A) ⇒ Unit): Unit

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

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

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

def toArray(): Array[(VertexId, VD)]