Abstract Value Members
-
abstract
def
ANY: Rdf.NodeAny
-
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
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]
-
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
makeGraph(it: Iterable[Rdf.Triple]): 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
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
resolve(uri: Rdf.URI, other: Rdf.URI): Rdf.URI
-
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
-
abstract
def
withoutFragment(uri: Rdf.URI): Rdf.URI
Concrete Value Members
-
final
def
!=(arg0: AnyRef): Boolean
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
+(other: String): String
-
def
->[B](y: B): (RDFOps[Rdf], B)
-
final
def
==(arg0: AnyRef): Boolean
-
final
def
==(arg0: Any): Boolean
-
-
-
-
-
-
object
URI
-
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
-
def
isURI[T](node: Rdf.Node): Boolean
-
implicit
def
literalW(literal: Rdf.Literal): LiteralW[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]
-
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
-
def
toString(): String
-
implicit
def
tripleAsTripleMatch(triple: Rdf.Triple): (Rdf.NodeMatch, Rdf.NodeMatch, Rdf.NodeMatch)
-
implicit
def
tripleMatchW(tripleMatch: (Rdf.NodeMatch, Rdf.NodeMatch, Rdf.NodeMatch)): TripleMatchW[Rdf]
-
implicit
def
tripleSyntax(triple: Rdf.Triple): TripleW[Rdf]
-
implicit
def
triplesAsTripleMatches(triples: Iterable[Rdf.Triple]): Iterable[(Rdf.NodeMatch, Rdf.NodeMatch, Rdf.NodeMatch)]
-
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)
Shadowed Implicit Value Members
-
val
self: Any
-
val
self: Any
Inherited from AnyRef
Inherited from Any
Inherited by implicit conversion any2stringadd from
RDFOps[Rdf] to StringAdd
Inherited by implicit conversion any2stringfmt from
RDFOps[Rdf] to StringFormat
Inherited by implicit conversion any2ArrowAssoc from
RDFOps[Rdf] to ArrowAssoc[RDFOps[Rdf]]
Inherited by implicit conversion any2Ensuring from
RDFOps[Rdf] to Ensuring[RDFOps[Rdf]]
A Module that gathers the types needed to define an RDF implementation Closely based on http://www.w3.org/TR/rdf11-concepts/ But with the notable exceptions: