RDFOps

abstract def ANY: Rdf.NodeAny

abstract def addTriple(mgraph: Rdf.MGraph, triple: Rdf.Triple): mgraph.type

abstract def appendSegment(uri: Rdf.URI, segment: String): Rdf.URI

abstract def diff(g1: Rdf.Graph, g2: Rdf.Graph): Rdf.Graph

abstract def emptyGraph: Rdf.Graph

abstract def exists(mgraph: Rdf.MGraph, triple: Rdf.Triple): Boolean

abstract def find(graph: Rdf.Graph, subject: Rdf.NodeMatch, predicate: Rdf.NodeMatch, objectt: Rdf.NodeMatch): Iterator[Rdf.Triple]

abstract def foldNode[T](node: Rdf.Node)(funURI: (Rdf.URI) ⇒ T, funBNode: (Rdf.BNode) ⇒ T, funLiteral: (Rdf.Literal) ⇒ T): T

abstract def foldNodeMatch[T](nodeMatch: Rdf.NodeMatch)(funANY: ⇒ T, funNode: (Rdf.Node) ⇒ T): T

abstract def fromBNode(bn: Rdf.BNode): String

abstract def fromLang(l: Rdf.Lang): String

abstract def fromLiteral(literal: Rdf.Literal): (String, Rdf.URI, Option[Rdf.Lang])

abstract def fromTriple(triple: Rdf.Triple): (Rdf.Node, Rdf.URI, Rdf.Node)

abstract def fromUri(uri: Rdf.URI): String

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

returns the fragment part of uri

abstract def getString(uri: Rdf.URI): String

abstract def getTriples(graph: Rdf.Graph): Iterable[Rdf.Triple]

abstract def graphSize(g: Rdf.Graph): Int

abstract def isPureFragment(uri: Rdf.URI): Boolean

abstract def isomorphism(left: Rdf.Graph, right: Rdf.Graph): Boolean

abstract def lastSegment(uri: Rdf.URI): String

abstract def makeBNode(): Rdf.BNode

abstract def makeBNodeLabel(s: String): Rdf.BNode

abstract def makeEmptyMGraph(): Rdf.MGraph

abstract def makeGraph(it: Iterable[Rdf.Triple]): Rdf.Graph

abstract def makeIGraph(mgraph: Rdf.MGraph): Rdf.Graph

abstract def makeLang(s: String): Rdf.Lang

abstract def makeLangTaggedLiteral(lexicalForm: String, lang: Rdf.Lang): Rdf.Literal

abstract def makeLiteral(lexicalForm: String, datatype: Rdf.URI): Rdf.Literal

abstract def makeMGraph(graph: Rdf.Graph): Rdf.MGraph

abstract def makeTriple(s: Rdf.Node, p: Rdf.URI, o: Rdf.Node): Rdf.Triple

abstract def makeUri(s: String): Rdf.URI

abstract def relativize(uri: Rdf.URI, other: Rdf.URI): Rdf.URI

abstract def removeTriple(mgraph: Rdf.MGraph, triple: Rdf.Triple): mgraph.type

abstract def resolve(uri: Rdf.URI, other: Rdf.URI): Rdf.URI

abstract def sizeMGraph(mgraph: Rdf.MGraph): Int

implicit abstract def toConcreteNodeMatch(node: Rdf.Node): Rdf.NodeMatch

abstract def union(graphs: Seq[Rdf.Graph]): Rdf.Graph

abstract def withFragment(uri: Rdf.URI, frag: String): Rdf.URI

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

abstract def withoutFragment(uri: Rdf.URI): Rdf.URI

returns uri without its fragment part if it had one

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (RDFOps[Rdf], B)

final def ==(arg0: Any): Boolean

object BNode

object Graph

object Lang

object Literal

object Triple

object URI

final def addTriples(mgraph: Rdf.MGraph, triples: TraversableOnce[Rdf.Triple]): mgraph.type

implicit def anyW[T](t: T): AnyW[Rdf, T]

final def asInstanceOf[T0]: T0

def bnode(s: String): Rdf.BNode

def bnode(): Rdf.BNode

def clone(): AnyRef

def ensuring(cond: (RDFOps[Rdf]) ⇒ Boolean, msg: ⇒ Any): RDFOps[Rdf]

def ensuring(cond: (RDFOps[Rdf]) ⇒ Boolean): RDFOps[Rdf]

def ensuring(cond: Boolean, msg: ⇒ Any): RDFOps[Rdf]

def ensuring(cond: Boolean): RDFOps[Rdf]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def formatted(fmtstr: String): String

final def getClass(): Class[_]

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

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

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

implicit def graphW(graph: Rdf.Graph): GraphW[Rdf]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

implicit def literalW(literal: Rdf.Literal): LiteralW[Rdf]

implicit def mgraphW(mgraph: Rdf.MGraph): MGraphW[Rdf]

final def ne(arg0: AnyRef): Boolean

implicit def nodeMatchW(nodeMatch: Rdf.NodeMatch): NodeMatchW[Rdf]

implicit def nodeW(node: Rdf.Node): NodeW[Rdf]

final def notify(): Unit

final def notifyAll(): Unit

lazy val rdf: RDFPrefix[Rdf]

final def removeTriples(mgraph: Rdf.MGraph, triples: TraversableOnce[Rdf.Triple]): mgraph.type

implicit def sparqlSolutionSyntax(solution: Rdf.Solution): SparqlSolutionSyntaxW[Rdf]

implicit def sparqlSolutionsSyntax(solutions: Rdf.Solutions): SparqlSolutionsSyntaxW[Rdf]

implicit def stringW(s: String): StringW[Rdf]

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

implicit def toPointedGraphW[Rdf <: RDF](pointed: PointedGraph[Rdf]): PointedGraphW[Rdf]

implicit def toPointedGraphW(node: Rdf.Node)(implicit ops: RDFOps[Rdf]): PointedGraphW[Rdf]

def toString(): String

implicit def tripleAsTripleMatch(triple: Rdf.Triple): TripleMatch[Rdf]

implicit def tripleMatchW(tripleMatch: TripleMatch[Rdf]): TripleMatchW[Rdf]

implicit def tripleSyntax(triple: Rdf.Triple): TripleW[Rdf]

implicit def triplesAsTripleMatches(triples: Iterable[Rdf.Triple]): Iterable[TripleMatch[Rdf]]

implicit def uriW(uri: Rdf.URI): URIW[Rdf]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

lazy val xsd: XSDPrefix[Rdf]

def →[B](y: B): (RDFOps[Rdf], B)