VertexRDDImpl

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
def ++(other: RDD[(VertexId, VD)]): RDD[(VertexId, VD)]

Definition Classes
RDD
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def aggregate[U](zeroValue: U)(seqOp: (U, (VertexId, VD)) ⇒ U, combOp: (U, U) ⇒ U)(implicit arg0: ClassTag[U]): U

Definition Classes
RDD
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.
Aggregates vertices in messages that have the same ids using reduceFunc, returning a VertexRDD co-indexed with this.
messages
an RDD containing messages to aggregate, where each message is a pair of its target vertex ID and the message data
reduceFunc
the associative aggregation function for merging messages to the same vertex
returns
a VertexRDD co-indexed with this, containing only vertices that received messages. For those vertices, their values are the result of applying reduceFunc to all received messages.

Definition Classes
VertexRDDImpl → VertexRDD
final def asInstanceOf[T0]: T0

Definition Classes
Any
def cache(): VertexRDDImpl.this.type

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

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

Definition Classes
RDD
def checkpoint(): Unit

Definition Classes
VertexRDDImpl → RDD
def clearDependencies(): Unit

Attributes
protected
Definition Classes
RDD
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def coalesce(numPartitions: Int, shuffle: Boolean, partitionCoalescer: Option[PartitionCoalescer])(implicit ord: Ordering[(VertexId, VD)]): RDD[(VertexId, VD)]

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

Definition Classes
RDD
def collect(): Array[(VertexId, VD)]

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

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

Definition Classes
VertexRDD → RDD
def context: SparkContext

Definition Classes
RDD
def count(): Long

The number of vertices in the RDD.
The number of vertices in the RDD.

Definition Classes
VertexRDDImpl → RDD
def countApprox(timeout: Long, confidence: Double): PartialResult[BoundedDouble]

Definition Classes
RDD
def countApproxDistinct(relativeSD: Double): Long

Definition Classes
RDD
def countApproxDistinct(p: Int, sp: Int): Long

Definition Classes
RDD
def countByValue()(implicit ord: Ordering[(VertexId, VD)]): Map[(VertexId, VD), Long]

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

Definition Classes
RDD
final def dependencies: Seq[Dependency[_]]

Definition Classes
RDD
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.
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. This is only guaranteed to work if the VertexRDDs share a common ancestor.
other
the other VertexRDD with which to diff against.

Definition Classes
VertexRDDImpl → VertexRDD
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.
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. This is only guaranteed to work if the VertexRDDs share a common ancestor.
other
the other RDD[(VertexId, VD)] with which to diff against.

Definition Classes
VertexRDDImpl → VertexRDD
def distinct(): RDD[(VertexId, VD)]

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

Definition Classes
RDD
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def filter(pred: ((VertexId, VD)) ⇒ Boolean): VertexRDD[VD]

Restricts the vertex set to the set of vertices satisfying the given predicate.
Restricts the vertex set to the set of vertices satisfying the given predicate. This operation preserves the index for efficient joins with the original RDD, and it sets bits in the bitmask rather than allocating new memory.
It is declared and defined here to allow refining the return type from RDD[(VertexId, VD)] to VertexRDD[VD].
pred
the user defined predicate, which takes a tuple to conform to the RDD[(VertexId, VD)] interface

Definition Classes
VertexRDD → RDD
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def first(): (VertexId, VD)

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

Attributes
protected[org.apache.spark]
Definition Classes
RDD
def flatMap[U](f: ((VertexId, VD)) ⇒ TraversableOnce[U])(implicit arg0: ClassTag[U]): RDD[U]

Definition Classes
RDD
def fold(zeroValue: (VertexId, VD))(op: ((VertexId, VD), (VertexId, VD)) ⇒ (VertexId, VD)): (VertexId, VD)

Definition Classes
RDD
def foreach(f: ((VertexId, VD)) ⇒ Unit): Unit

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

Definition Classes
RDD
def getCheckpointFile: Option[String]

Definition Classes
VertexRDDImpl → RDD
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getDependencies: Seq[Dependency[_]]

Attributes
protected
Definition Classes
RDD
final def getNumPartitions: Int

Definition Classes
RDD
Annotations
@Since( "1.6.0" )
def getOutputDeterministicLevel: rdd.DeterministicLevel.Value

Attributes
protected
Definition Classes
RDD
Annotations
@DeveloperApi()
def getPartitions: Array[Partition]

Attributes
protected
Definition Classes
VertexRDD → RDD
def getPreferredLocations(s: Partition): Seq[String]

Attributes
protected
Definition Classes
VertexRDDImpl → RDD
def getStorageLevel: StorageLevel

Definition Classes
VertexRDDImpl → RDD
def glom(): RDD[Array[(VertexId, VD)]]

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

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

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

Definition Classes
RDD
def hashCode(): Int

Definition Classes
AnyRef → Any
val id: Int

Definition Classes
RDD
def initializeLogIfNecessary(isInterpreter: Boolean): Unit

Attributes
protected
Definition Classes
Logging
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.
Inner joins this VertexRDD with an RDD containing vertex attribute pairs. If the other RDD is backed by a VertexRDD with the same index then the efficient innerZipJoin implementation is used.
other
an RDD containing vertices to join. If there are multiple entries for the same vertex, one is picked arbitrarily. Use aggregateUsingIndex to merge multiple entries.
f
the join function applied to corresponding values of this and other
returns
a VertexRDD co-indexed with this, containing only vertices that appear in both this and other, with values supplied by f

Definition Classes
VertexRDDImpl → VertexRDD
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.
Efficiently inner joins this VertexRDD with another VertexRDD sharing the same index. See innerJoin for the behavior of the join.

Definition Classes
VertexRDDImpl → VertexRDD
def intersection(other: RDD[(VertexId, VD)], numPartitions: Int): RDD[(VertexId, VD)]

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

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

Definition Classes
RDD
def isCheckpointed: Boolean

Definition Classes
VertexRDDImpl → RDD
def isEmpty(): Boolean

Definition Classes
RDD
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isTraceEnabled(): Boolean

Attributes
protected
Definition Classes
Logging
final def iterator(split: Partition, context: TaskContext): Iterator[(VertexId, VD)]

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

Definition Classes
RDD
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.
Left joins this VertexRDD with an RDD containing vertex attribute pairs. If the other RDD is backed by a VertexRDD with the same index then the efficient leftZipJoin implementation is used. The resulting VertexRDD contains an entry for each vertex in this. If other is missing any vertex in this VertexRDD, f is passed None. If there are duplicates, the vertex is picked arbitrarily.
VD2
the attribute type of the other VertexRDD
VD3
the attribute type of the resulting VertexRDD
other
the other VertexRDD with which to join
f
the function mapping a vertex id and its attributes in this and the other vertex set to a new vertex attribute.
returns
a VertexRDD containing all the vertices in this VertexRDD with the attributes emitted by f.

Definition Classes
VertexRDDImpl → VertexRDD
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.
Left joins this RDD with another VertexRDD with the same index. This function will fail if both VertexRDDs do not share the same index. The resulting vertex set contains an entry for each vertex in this. If other is missing any vertex in this VertexRDD, f is passed None.
VD2
the attribute type of the other VertexRDD
VD3
the attribute type of the resulting VertexRDD
other
the other VertexRDD with which to join.
f
the function mapping a vertex id and its attributes in this and the other vertex set to a new vertex attribute.
returns
a VertexRDD containing the results of f

Definition Classes
VertexRDDImpl → VertexRDD
def localCheckpoint(): VertexRDDImpl.this.type

Definition Classes
RDD
def log: Logger

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logDebug(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logError(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logInfo(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logName: String

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logTrace(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String, throwable: Throwable): Unit

Attributes
protected
Definition Classes
Logging
def logWarning(msg: ⇒ String): Unit

Attributes
protected
Definition Classes
Logging
def map[U](f: ((VertexId, VD)) ⇒ U)(implicit arg0: ClassTag[U]): RDD[U]

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

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

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

Maps each vertex attribute, additionally supplying the vertex ID.
Maps each vertex attribute, additionally supplying the vertex ID.
VD2
the type returned by the map function
f
the function applied to each ID-value pair in the RDD
returns
a new VertexRDD with values obtained by applying f to each of the entries in the original VertexRDD. The resulting VertexRDD retains the same index.

Definition Classes
VertexRDDImpl → VertexRDD
def mapValues[VD2](f: (VD) ⇒ VD2)(implicit arg0: ClassTag[VD2]): VertexRDD[VD2]

Maps each vertex attribute, preserving the index.
Maps each vertex attribute, preserving the index.
VD2
the type returned by the map function
f
the function applied to each value in the RDD
returns
a new VertexRDD with values obtained by applying f to each of the entries in the original VertexRDD

Definition Classes
VertexRDDImpl → VertexRDD
def max()(implicit ord: Ordering[(VertexId, VD)]): (VertexId, VD)

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

Definition Classes
RDD
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.
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.
other
a VertexRDD to run the set operation against

Definition Classes
VertexRDDImpl → VertexRDD
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.
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.
other
an RDD to run the set operation against

Definition Classes
VertexRDDImpl → VertexRDD
var name: String

Definition Classes
RDD
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

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

Attributes
protected[org.apache.spark]
Definition Classes
RDD
val partitioner: Option[Partitioner]

Definition Classes
VertexRDDImpl → RDD
final def partitions: Array[Partition]

Definition Classes
RDD
val partitionsRDD: RDD[ShippableVertexPartition[VD]]

Definition Classes
VertexRDDImpl → VertexRDD
def persist(newLevel: StorageLevel): VertexRDDImpl.this.type

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

Definition Classes
VertexRDDImpl → RDD
def persist(): VertexRDDImpl.this.type

Definition Classes
RDD
def pipe(command: Seq[String], env: Map[String, String], printPipeContext: ((String) ⇒ Unit) ⇒ Unit, printRDDElement: ((VertexId, VD), (String) ⇒ Unit) ⇒ Unit, separateWorkingDir: Boolean, bufferSize: Int, encoding: String): RDD[String]

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

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

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

Definition Classes
RDD
def randomSplit(weights: Array[Double], seed: Long): Array[RDD[(VertexId, VD)]]

Definition Classes
RDD
def reduce(f: ((VertexId, VD), (VertexId, VD)) ⇒ (VertexId, VD)): (VertexId, VD)

Definition Classes
RDD
def reindex(): VertexRDD[VD]

Construct a new VertexRDD that is indexed by only the visible vertices.
Construct a new VertexRDD that is indexed by only the visible vertices. The resulting VertexRDD will be based on a different index and can no longer be quickly joined with this RDD.

Definition Classes
VertexRDDImpl → VertexRDD
def repartition(numPartitions: Int)(implicit ord: Ordering[(VertexId, VD)]): RDD[(VertexId, VD)]

Definition Classes
RDD
def reverseRoutingTables(): VertexRDD[VD]

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

Definition Classes
VertexRDDImpl → VertexRDD
def sample(withReplacement: Boolean, fraction: Double, seed: Long): RDD[(VertexId, VD)]

Definition Classes
RDD
def saveAsObjectFile(path: String): Unit

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

Definition Classes
RDD
def saveAsTextFile(path: String): Unit

Definition Classes
RDD
def setName(_name: String): VertexRDDImpl.this.type

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

Definition Classes
RDD
def sparkContext: SparkContext

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

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

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

Definition Classes
RDD
final def synchronized[T0](arg0: ⇒ T0): T0

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

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

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

Definition Classes
RDD
val targetStorageLevel: StorageLevel
def toDebugString: String

Definition Classes
RDD
def toJavaRDD(): JavaRDD[(VertexId, VD)]

Definition Classes
RDD
def toLocalIterator: Iterator[(VertexId, VD)]

Definition Classes
RDD
def toString(): String

Definition Classes
RDD → AnyRef → Any
def top(num: Int)(implicit ord: Ordering[(VertexId, VD)]): Array[(VertexId, VD)]

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

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

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

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

Definition Classes
VertexRDDImpl → RDD
implicit val vdTag: ClassTag[VD]

Attributes
protected
Definition Classes
VertexRDDImpl → VertexRDD
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withEdges(edges: EdgeRDD[_]): VertexRDD[VD]

Prepares this VertexRDD for efficient joins with the given EdgeRDD.
Prepares this VertexRDD for efficient joins with the given EdgeRDD.

Definition Classes
VertexRDDImpl → VertexRDD
def zip[U](other: RDD[U])(implicit arg0: ClassTag[U]): RDD[((VertexId, VD), U)]

Definition Classes
RDD
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]

Definition Classes
RDD
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]

Definition Classes
RDD
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]

Definition Classes
RDD
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]

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

Definition Classes
RDD
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]

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

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

Definition Classes
RDD

Related Doc: package impl

class VertexRDDImpl[VD] extends VertexRDD[VD]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

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

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]

final def asInstanceOf[T0]: T0

def cache(): VertexRDDImpl.this.type

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, partitionCoalescer: Option[PartitionCoalescer])(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)]

def context: SparkContext

def count(): Long

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]

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

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]

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[_]]

final def getNumPartitions: Int

def getOutputDeterministicLevel: rdd.DeterministicLevel.Value

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 initializeLogIfNecessary(isInterpreter: Boolean): Unit

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

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

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]

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

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