SesameOps

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

def +(other: String): String

def ->[B](y: B): (SesameOps, B)

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

val ANY: Null

object URI

val __rdfLangString: URI

val __xsdString: URI

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

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

final def asInstanceOf[T0]: T0

def bnode(s: String): BNode

def bnode(): BNode

def clone(): AnyRef

def diff(g1: Model, g2: Model): Model

def emptyGraph: Model

def ensuring(cond: (SesameOps) ⇒ Boolean, msg: ⇒ Any): SesameOps

def ensuring(cond: (SesameOps) ⇒ Boolean): SesameOps

def ensuring(cond: Boolean, msg: ⇒ Any): SesameOps

def ensuring(cond: Boolean): SesameOps

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def find(graph: Model, subject: Value, predicate: Value, objectt: Value): Iterator[Statement]

def foldNode[T](node: Value)(funURI: (URI) ⇒ T, funBNode: (BNode) ⇒ T, funLiteral: (Literal) ⇒ T): T

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

def formatted(fmtstr: String): String

def fromBNode(bn: BNode): String

def fromLang(lang: String): String

def fromLiteral(literal: Literal): (String, URI, Option[String])

def fromTriple(t: Statement): (Value, URI, Value)

def fromUri(node: URI): String

final def getClass(): Class[_]

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

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

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

def getString(uri: URI): String

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

def getTriples(graph: Model): Iterable[Statement]

def graphSize(g: Model): Int

implicit def graphW(graph: Graph): GraphW[Sesame]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isPureFragment(uri: URI): Boolean

def isURI[T](node: Node): Boolean

def isomorphism(left: Model, right: Model): Boolean

the new ModelUtil.

def lastSegment(uri: URI): String

implicit def literalW(literal: Literal): LiteralW[Sesame]

def makeBNode(): BNode

def makeBNodeLabel(label: String): BNode

def makeGraph(it: Iterable[Statement]): Model

def makeLang(langString: String): String

language tags are cases insensitive according to RFC 5646: Tags for Identifying Languages which is referenced by RDF11 Concepts.

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

def makeLiteral(lexicalForm: String, datatype: URI): Literal

def makeTriple(s: Value, p: URI, o: Value): Statement

def makeUri(iriStr: String): URI

we provide our own builder for Sesame#URI to relax the constraint "the URI must be absolute" this constraint becomes relevant only when you add the URI to a Sesame store

final def ne(arg0: AnyRef): Boolean

implicit def nodeMatchW(nodeMatch: NodeMatch): NodeMatchW[Sesame]

implicit def nodeW(node: Node): NodeW[Sesame]

final def notify(): Unit

final def notifyAll(): Unit

lazy val rdf: RDFPrefix[Sesame]

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

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

implicit def sparqlSolutionSyntax(solution: Solution): SparqlSolutionSyntaxW[Sesame]

implicit def sparqlSolutionsSyntax(solutions: Solutions): SparqlSolutionsSyntaxW[Sesame]

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

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

implicit def toConcreteNodeMatch(node: Value): Value

def toString(): String

implicit def tripleAsTripleMatch(triple: Triple): (NodeMatch, NodeMatch, NodeMatch)

implicit def tripleMatchW(tripleMatch: (NodeMatch, NodeMatch, NodeMatch)): TripleMatchW[Sesame]

implicit def tripleSyntax(triple: Triple): TripleW[Sesame]

implicit def triplesAsTripleMatches(triples: Iterable[Triple]): Iterable[(NodeMatch, NodeMatch, NodeMatch)]

def union(graphs: Seq[Model]): Model

implicit def uriW(uri: URI): URIW[Sesame]

val valueFactory: ValueFactory

final def wait(): Unit

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

final def wait(arg0: Long): Unit

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

def withoutFragment(uri: URI): URI

lazy val xsd: XSDPrefix[Sesame]

def →[B](y: B): (SesameOps, B)

val self: Any

val self: Any

def x: SesameOps

def x: SesameOps