JenaSparkRDDOps

abstract def sparkContext: SparkContext

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def ANY: Node_ANY

object BNode

object Graph

object Lang

object Literal

object Triple

object URI

def __rdfLangStringURI: Node_URI

def __xsdString: RDFDatatype

def __xsdStringURI: Node_URI

def appendSegment(uri: JenaSparkRDD.URI, segment: String): JenaSparkRDD.URI

final def asInstanceOf[T0]: T0

def bnode(s: String): JenaSparkRDD.BNode

def bnode(): JenaSparkRDD.BNode

def clone(): AnyRef

def difference(g1: RDD[JenaSparkRDD.Triple], g2: RDD[JenaSparkRDD.Triple]): RDD[JenaSparkRDD.Triple]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def find(graph: RDD[JenaSparkRDD.Triple], subject: JenaSparkRDD.NodeMatch, predicate: JenaSparkRDD.NodeMatch, objectt: JenaSparkRDD.NodeMatch): Iterator[JenaSparkRDD.Triple]

def findGraph(graph: RDD[JenaSparkRDD.Triple], subject: JenaSparkRDD.NodeMatch, predicate: JenaSparkRDD.NodeMatch, objectt: JenaSparkRDD.NodeMatch): RDD[JenaSparkRDD.Triple]

def foldNode[T](node: Node)(funURI: (Node_URI) ⇒ T, funBNode: (Node_Blank) ⇒ T, funLiteral: (Node_Literal) ⇒ T): T

def foldNodeMatch[T](nodeMatch: Node)(funANY: ⇒ T, funConcrete: (Node) ⇒ T): T

def fromBNode(bn: Node_Blank): String

def fromLang(lang: String): String

def fromLiteral(literal: Node_Literal): (String, Node_URI, Option[String])

def fromNTriples(rdf: String, baseIRI: String): Iterable[Triple]

def fromTriple(t: Triple): (Node, Node_URI, Node)

def fromUri(node: Node_URI): String

final def getClass(): Class[_]

def getFragment(uri: JenaSparkRDD.URI): Option[String]

returns the fragment part of uri

def getObjects(graph: JenaSparkRDD.Graph, subject: JenaSparkRDD.Node, predicate: JenaSparkRDD.URI): Iterable[JenaSparkRDD.Node]

def getObjectsRDD(graph: RDD[JenaSparkRDD.Triple], predicate: JenaSparkRDD.URI): RDD[JenaSparkRDD.Node]

def getObjectsRDD(graph: RDD[JenaSparkRDD.Triple], subject: JenaSparkRDD.Node, predicate: JenaSparkRDD.URI): RDD[JenaSparkRDD.Node]

def getPredicates(graph: JenaSparkRDD.Graph, subject: JenaSparkRDD.Node): Iterable[JenaSparkRDD.URI]

def getPredicatesRDD(graph: RDD[JenaSparkRDD.Triple], subject: JenaSparkRDD.Node): RDD[JenaSparkRDD.URI]

def getString(uri: JenaSparkRDD.URI): String

def getSubjects(graph: JenaSparkRDD.Graph, predicate: JenaSparkRDD.URI, obj: JenaSparkRDD.Node): Iterable[JenaSparkRDD.Node]

def getSubjectsRDD(graph: RDD[JenaSparkRDD.Triple], predicate: JenaSparkRDD.URI): RDD[JenaSparkRDD.Node]

def getSubjectsRDD(graph: RDD[JenaSparkRDD.Triple], predicate: JenaSparkRDD.URI, obj: JenaSparkRDD.Node): RDD[JenaSparkRDD.Node]

def getTriples(graph: RDD[JenaSparkRDD.Triple]): Iterable[JenaSparkRDD.Triple]

def graphSize(g: RDD[JenaSparkRDD.Triple]): Long

def hashCode(): Int

def intersection(graphs: Seq[RDD[JenaSparkRDD.Triple]]): RDD[JenaSparkRDD.Triple]

final def isInstanceOf[T0]: Boolean

def isPureFragment(uri: JenaSparkRDD.URI): Boolean

def isomorphism(left: RDD[JenaSparkRDD.Triple], right: RDD[JenaSparkRDD.Triple]): Boolean

Implement Spark algorithm for determining whether left and right are isomorphic

def jenaDatatype(datatype: Node_URI): RDFDatatype

def lastSegment(uri: JenaSparkRDD.URI): String

def loadGraphFromNTriples(file: String, baseIRI: String): RDD[JenaSparkRDD.Triple]

def loadGraphFromSequenceFile(file: String): RDD[JenaSparkRDD.Triple]

def makeBNode(): Node_Blank

def makeBNodeLabel(label: String): Node_Blank

def makeGraph(triples: Iterable[JenaSparkRDD.Triple]): RDD[JenaSparkRDD.Triple]

def makeLang(langString: String): String

def makeLangTaggedLiteral(lexicalForm: String, lang: String): Node_Literal

def makeLiteral(lexicalForm: String, datatype: Node_URI): Node_Literal

def makeTriple(s: Node, p: Node_URI, o: Node): Triple

def makeUri(iriStr: String): Node_URI

final def matchNode[T <: JenaSparkRDD](node: RDFNodeOps.matchNode.T.Node, nodeMatch: RDFNodeOps.matchNode.T.NodeMatch): Boolean

def matches(node1: Node, node2: Node): Boolean

final def ne(arg0: AnyRef): Boolean

implicit def nodeTag: ClassTag[JenaSparkRDD.Node]

final def notify(): Unit

final def notifyAll(): Unit

def relativize(uri: JenaSparkRDD.URI, other: JenaSparkRDD.URI): JenaSparkRDD.URI

def resolve(uri: JenaSparkRDD.URI, against: JenaSparkRDD.URI): JenaSparkRDD.URI

def saveGraphToNTriples(graph: RDD[JenaSparkRDD.Triple], file: String): Unit

def saveGraphToSequenceFile(graph: RDD[JenaSparkRDD.Triple], file: String): Unit

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

implicit def toConcreteNodeMatch(node: Node): Node

def toNTriples(triples: Iterable[Triple]): String

def toString(): String

implicit def tripleTag: ClassTag[JenaSparkRDD.URI]

def union(graphs: Seq[RDD[JenaSparkRDD.Triple]]): RDD[JenaSparkRDD.Triple]

implicit def uriTag: ClassTag[JenaSparkRDD.Triple]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withFragment(uri: JenaSparkRDD.URI, frag: String): JenaSparkRDD.URI

returns uri with frag as its fragment part, newly added or replaced

def withoutFragment(uri: JenaSparkRDD.URI): JenaSparkRDD.URI

returns uri without its fragment part if it had one