object JenaUtils
- Source
- JenaUtils.scala
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- JenaUtils
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- lazy val N3: String
- lazy val NTriple: String
- lazy val RdfXML: String
- lazy val RdfXMLAbbr: String
- lazy val TTL: String
- lazy val Turtle: String
- lazy val any: Resource
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @HotSpotIntrinsicCandidate()
- def dereferenceURI(uri: String): InputStream
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def extractModel(resource: Resource, model: Model): Model
- def findProperty(m: Model, r: Resource, p: Property): RDFNode
- def findProperty_asLiteral(m: Model, r: Resource, p: Property): Literal
- def findProperty_asResource(m: Model, r: Resource, p: Property): Resource
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def getDirectInstances(n: RDFNode, model: Model): IO[Set[Resource]]
- def getDirectTypes(n: RDFNode, model: Model): Set[RDFNode]
- def getLiteral(r: RDFNode, property: Property): String
- def getNodesFromPath(path: Path, model: Model): IO[List[(RDFNode, RDFNode)]]
- def getObjectURI(r: RDFNode, p: Property): URI
- def getResource(node: RDFNode): Option[Resource]
-
def
getSHACLInstances(cls: RDFNode, model: Model): IO[Seq[RDFNode]]
Given a class
cls
, obtains all nodes such asnode rdf:type/rdfs:subClassOf* cls
- def getSHACLTypes(n: RDFNode, model: Model): IO[Set[RDFNode]]
- def getSuperClasses(c: RDFNode, model: Model): IO[Set[RDFNode]]
- def getURI(r: RDFNode): URI
-
def
hasClass(n: RDFNode, c: RDFNode, model: Model): IO[Boolean]
Checks is a
node rdf:type/rdfs:subClassOf* cls
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def inference(rdf: Model, inference: String): IO[Model]
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def model2File(model: Model, fileName: String, syntax: String = Turtle): Unit
- def model2Str(model: Model, syntax: String = Turtle): String
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def objectsFromPath(subj: RDFNode, path: Path, model: Model): Seq[RDFNode]
- def parseFromString(content: String, base: String = "", syntax: String = Turtle): IO[Model]
- def parseFromURI(uri: String, base: String = "", syntax: String = Turtle): IO[Model]
-
def
parseInputStream(stream: InputStream, base: String = "", syntax: String = Turtle): ParserReport[Model, String]
Returns a RDF model after parsing an InputStream
- def queryConstructModel(query: Query, model: Model): Model
- def queryConstructModel(queryStr: String, model: Model): Model
- def querySelectModel(queryStr: String, model: Model): ResultSet
- def querySelectModel(query: Query, model: Model): ResultSet
- lazy val rdfTypeUrl: String
- def relativizeModel(m: Model, base: Option[URI]): Model
- def relativizeNode(m: Model, n: RDFNode, base: Option[URI]): RDFNode
- def relativizeProperty(m: Model, r: Property, base: Option[URI]): Property
- def relativizeResource(m: Model, r: Resource, base: Option[URI]): Resource
- def relativizeStr(str: String, base: Option[URI]): String
- def sameNodeAs(v1: RDFNode, v2: RDFNode): Boolean
-
def
showResource(resource: Resource): String
Shows infomation about a resource (list all the statements)
-
def
str2Model(str: String, base: String = "", syntax: String = Turtle): ParserReport[Model, String]
Returns a RDF model after parsing a String
- lazy val subClassOfUrl: String
- def subjectsFromPath(obj: RDFNode, path: Path, model: Model): Seq[RDFNode]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
-
def
toString(): String
- Definition Classes
- AnyRef → Any
- def uri2Model(uriName: String, base: String = "", syntax: String = Turtle): ParserReport[Model, String]
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )