Package | Description |
---|---|
com.hp.hpl.jena.db |
A general database backend for persistent storage of Jena models.
|
com.hp.hpl.jena.enhanced |
This package defines the enhanced node and graph classes; an enhanced
node is one embedded in a particular enhanced graph.
|
com.hp.hpl.jena.graph |
This package defines the Graph and Node family of classes, which
form the underlying datatypes of the Jena system.
|
com.hp.hpl.jena.graph.compose |
This package defines simple composite graphs - union, intersection,
difference, and update-tracking.
|
com.hp.hpl.jena.graph.query |
Defines the graph-level Query classes, allowing multi-pattern query
over arbitrary graphs.
|
com.hp.hpl.jena.ontology |
Provides a set of abstractions and convenience classes for accessing and manipluating ontologies
represented in RDF.
|
com.hp.hpl.jena.rdf.model |
A package for creating and manipulating RDF graphs.
|
com.hp.hpl.jena.reasoner |
The Jena2 reasoner subsystem is designed to allow a range of inference
engines to be plugged into Jena.
|
com.hp.hpl.jena.reasoner.rulesys |
Provides a selection of simple rule engines for Jena inference models.
|
com.hp.hpl.jena.reasoner.rulesys.builtins |
Implementations of the Builtin class which provides primitive operations to the rule
engines.
|
com.hp.hpl.jena.reasoner.transitiveReasoner |
This package contains a reasoner which supports transitive-reflexive closure
of subPropertyOf and subClassOf relations.
|
com.hp.hpl.jena.shared |
This package defines some classes common to the Jena API
and SPI levels, in particular the JenaException class from which
all Jena-specific exceptions hang, and the interface PrefixMapping
for translation to and from QNames.
|
com.hp.hpl.jena.util |
Miscellaneous collection of utility classes.
|
com.hp.hpl.jena.vocabulary |
A package containing constant classes with predefined constant objects
for classes and properties defined in well known vocabularies.
|
Modifier and Type | Method and Description |
---|---|
Node |
GraphRDB.getNode()
Returns the Node for this model in the system properties graph.
|
Modifier and Type | Method and Description |
---|---|
Node |
EnhNode.asNode()
Answer the graph node that this enhanced node wraps
|
Modifier and Type | Method and Description |
---|---|
abstract boolean |
Implementation.canWrap(Node node,
EnhGraph eg)
true iff wrapping (node, eg) would succeed.
|
<X extends RDFNode> |
EnhGraph.getNodeAs(Node n,
Class<X> interf)
Answer an enhanced node that wraps the given node and conforms to the given
interface type.
|
<X extends T> |
Personality.newInstance(Class<X> interf,
Node n,
EnhGraph that)
make a new instance of a type _interf_ based on the node _n_ and the
polymorphic _that_; use the implementation wrapper for _interf_ in
_types_.
|
abstract EnhNode |
Implementation.wrap(Node node,
EnhGraph eg)
Create a new EnhNode wrapping a Node in the context of an EnhGraph
|
Constructor and Description |
---|
EnhNode(Node n,
EnhGraph g) |
Modifier and Type | Class and Description |
---|---|
class |
Node_ANY
A Node_ANY (there should be only one) is a meta-node that is used to stand
for any other node in a query.
|
class |
Node_Blank
RDF blank nodes, ie nodes with identity but without URIs.
|
class |
Node_Concrete
This is the class of "concrete" nodes, ie those which correspond
to actual RDF data - URIs, blank nodes, and literals.
|
class |
Node_Fluid
This is the subclass of "fluid" nodes, ie nodes that are "holes" in pattern
matching.
|
class |
Node_Literal
An RDF node holding a literal value.
|
class |
Node_NULL
The Highlander Node_NULL exists for the database code (as a Node that
coresponds to a null in database tables for the reification code).
|
class |
Node_URI
RDF nodes with a global identity given by a URI.
|
class |
Node_Variable
"variable" nodes; these are outside the RDF2003 specification, but are
used internally for "placeholder" nodes where blank nodes would be
wrong, most specifically in Query.
|
Modifier and Type | Field and Description |
---|---|
static Node |
Node.ANY
The canonical instance of Node_ANY.
|
static Node |
Node.NULL
The canonical NULL.
|
Modifier and Type | Field and Description |
---|---|
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node> |
Triple.getObject |
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node> |
Triple.getPredicate |
static com.hp.hpl.jena.util.iterator.Map1<Triple,Node> |
Triple.getSubject |
Modifier and Type | Method and Description |
---|---|
Node |
FrontsNode.asNode()
Answer the Node associated with this object.
|
static Node |
Node.create(com.hp.hpl.jena.graph.Node.NodeMaker maker,
Object label)
We object strongly to null labels: for example, they make .equals flaky.
|
static Node |
Node.createAnon()
make a blank node with a fresh anon id
|
static Node |
Node.createAnon(AnonId id)
make a blank node with the specified label
|
static Node |
Node.createLiteral(com.hp.hpl.jena.graph.impl.LiteralLabel lit)
make a literal node with the specified literal value
|
static Node |
Node.createLiteral(String value) |
static Node |
Node.createLiteral(String lit,
String lang,
boolean isXml)
make a literal with specified language and XMLishness.
|
static Node |
Node.createLiteral(String lex,
String lang,
RDFDatatype dtype)
Build a typed literal node from its lexical form.
|
static Node |
Node.createUncachedLiteral(Object value,
String lang,
RDFDatatype dtype) |
static Node |
Node.createURI(String uri)
make a URI node with the specified URIref string
|
static Node |
Node.createVariable(String name)
make a variable node with a given name
|
Node |
NodeCache.get(Object label)
Answer the node with the given
label in the cache, or
null if there isn't one. |
abstract Node |
Triple.Field.getField(Triple t) |
Node |
TripleMatch.getMatchObject()
If it is known that all triples selected by this match will
have a common object, return that node, otherwise return null
|
Node |
Triple.getMatchObject() |
Node |
TripleMatch.getMatchPredicate()
If it is known that all triples selected by this match will
have a common predicate, return that node, otherwise return null
|
Node |
Triple.getMatchPredicate() |
Node |
TripleMatch.getMatchSubject()
If it is known that all triples selected by this filter will
have a common subject, return that node, otherwise return null
|
Node |
Triple.getMatchSubject() |
Node |
Triple.getObject() |
Node |
Triple.getPredicate() |
Node |
Triple.getSubject() |
Node |
Reifier.reifyAs(Node n,
Triple t)
note the triple _t_ as reified using _n_ as its representing node.
|
Modifier and Type | Method and Description |
---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
Reifier.allNodes()
return an iterator over all the nodes that are reifiying something in
this reifier.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
Reifier.allNodes(Triple t)
return an iterator over all the nodes that are reifiying t in
this reifier.
|
Modifier and Type | Method and Description |
---|---|
boolean |
Graph.contains(Node s,
Node p,
Node o)
Answer true iff the graph contains a triple matching (s, p, o).
|
static boolean |
Reifier.Util.couldBeStatement(Node node) |
static Triple |
Triple.create(Node s,
Node p,
Node o)
Factory method for creating triples, allows caching opportunities.
|
static Triple |
Triple.createMatch(Node s,
Node p,
Node o) |
Graph |
GraphExtract.extract(Node node,
Graph graph)
Answer a new graph which is the reachable subgraph from
node
in graph with the terminating condition given by the
TripleBoundary passed to the constructor. |
Graph |
GraphExtract.extractInto(Graph toUpdate,
Node root,
Graph extractFrom)
Answer the graph
toUpdate augmented with the sub-graph of
extractFrom reachable from root bounded
by this instance's TripleBoundary. |
abstract com.hp.hpl.jena.util.iterator.Filter<Triple> |
Triple.Field.filterOn(Node n) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
Graph.find(Node s,
Node p,
Node o)
Returns an iterator over Triple.
|
Triple |
TripleCache.get(Node s,
Node p,
Node o)
Answer any triple in the cache with subject
s , predicate
p , and object o , or null if
no such triple exists. |
long |
GraphStatisticsHandler.getStatistic(Node S,
Node P,
Node O)
Answer a good estimate of the number of triples that would match the
pattern
(S, P, O) , or -1 if no good estimate is available. |
Triple |
GetTriple.getTriple(Node n)
Answer the triple associated with the node
n . |
static int |
Triple.hashCode(Node s,
Node p,
Node o)
Return the munged hashCodes of the specified nodes, an exclusive-or of
the slightly-shifted component hashcodes; this means (almost) all of the bits
count, and the order matters, so (S @P O) has a different hash from
(O @P S), etc.
|
boolean |
Reifier.hasTriple(Node n)
true iff _n_ is associated with some triple.
|
static boolean |
Reifier.Util.isReificationPredicate(Node node) |
static boolean |
Reifier.Util.isReificationType(Node P,
Node O) |
boolean |
Node_ANY.matches(Node other) |
boolean |
Node_Literal.matches(Node x) |
boolean |
Node.matches(Node other)
Answer true iff this node accepts the other one as a match.
|
boolean |
Triple.matches(Node s,
Node p,
Node o) |
boolean |
Triple.objectMatches(Node o) |
boolean |
Triple.predicateMatches(Node p) |
void |
NodeCache.put(Object label,
Node cached)
Record in the cache the designated Node, using the given label (which must
be .equals() to the Node's label).
|
Node |
Reifier.reifyAs(Node n,
Triple t)
note the triple _t_ as reified using _n_ as its representing node.
|
static GraphEvents |
GraphEvents.remove(Node s,
Node p,
Node o) |
void |
BulkUpdateHandler.remove(Node s,
Node p,
Node o)
Remove all triples that would be delivered by find(s, p, o)
|
void |
Reifier.remove(Node n,
Triple t)
remove any existing binding for _n_; hasNode(n) will return false
and getTriple(n) will return null.
|
boolean |
Triple.sameAs(Node s,
Node p,
Node o)
Answer true iff this triple has subject s, predicate p, and object o.
|
boolean |
Triple.subjectMatches(Node s) |
Constructor and Description |
---|
Node.NotLiteral(Node it) |
Triple(Node s,
Node p,
Node o) |
Modifier and Type | Method and Description |
---|---|
long |
MultiUnion.MultiUnionStatisticsHandler.getStatistic(Node S,
Node P,
Node O) |
Modifier and Type | Field and Description |
---|---|
static Node |
Query.ANY
A convenient synonym for Node.ANY, used in a match to match anything.
|
Node |
QueryNode.node
The Node value on which this QueryNode is based.
|
static Node |
Query.O
A query variable called "O".
|
static Node |
Query.P
A query variable called "P".
|
static Node |
Query.S
A query variable called "S".
|
static Node |
Query.X
A query variable called "X".
|
static Node |
Query.Y
A query variable called "Y".
|
static Node |
Query.Z
A query variable called "Z".
|
Modifier and Type | Method and Description |
---|---|
abstract Node |
Element.asNodeMatch(Domain d)
Answer a Node suitable as a pattern-match element in a TripleMatch approximating
this Element.
|
Node |
Bound.asNodeMatch(Domain d) |
Node |
Bind.asNodeMatch(Domain d)
Answer Node.ANY, as a binding occurance of a variable can match anything.
|
Node |
Fixed.asNodeMatch(Domain d)
Answer the Node we represent given the variable-bindings Domain.
|
Node |
QueryNode.finder(Domain d)
Answer a Node value to use when this QueryValue is used to select
objects in a Graph::find() operation; for concrete nodes, that very
node, for variables their current value (ANY if not bound).
|
Node |
QueryNode.Fixed.finder(Domain d) |
Node |
QueryNode.Bound.finder(Domain d) |
Node |
Domain.get(int i) |
Node |
Domain.getElement(int i) |
Modifier and Type | Method and Description |
---|---|
static Set<Node> |
SimpleTreeQueryPlan.getRoots(Graph pattern) |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.objectsFor(Graph g,
Node s,
Node p) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
QueryHandler.objectsFor(Node s,
Node p)
deliver an iterator over all the objects _o_ such that _(s, p, o)_ is in the
underlying graph; nulls count as wildcards.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.objectsFor(Node s,
Node p) |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.predicatesFor(Graph g,
Node s,
Node o) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
QueryHandler.predicatesFor(Node s,
Node o)
Answer an iterator over all the predicates
p such that
(s, p, o) is in the underlying graph. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.predicatesFor(Node s,
Node o) |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.subjectsFor(Graph g,
Node p,
Node o) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
QueryHandler.subjectsFor(Node p,
Node o)
deliver an iterator over all the subjects _s_ such that _(s, p, o)_ is in the
underlying graph; nulls count as wildcards.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.subjectsFor(Node p,
Node o) |
Modifier and Type | Method and Description |
---|---|
Query |
Query.addMatch(Node s,
Node p,
Node o)
Add an (S, P, O) match to the query's collection of match triples.
|
Element |
PatternCompiler.bind(Node n,
int index)
Method called to deliver a compiled element from a binding occurance of a
variable Node allocated at a given index position.
|
Element |
PatternStageCompiler.bind(Node n,
int index) |
Element |
PatternCompiler.bound(Node n,
int index)
Method called to deliver a compiled element from a bound occurance of a
variable Node allocated at a given index position.
|
Element |
PatternStageCompiler.bound(Node n,
int index) |
static QueryNode |
QueryNode.classify(QueryNodeFactory f,
Mapping map,
Set<Node> recent,
Node n)
Answer a QueryNode that classifies the argument node
n . |
boolean |
QueryHandler.containsNode(Node n)
true iff the graph contains a triple in which n appears somewhere.
|
boolean |
SimpleQueryHandler.containsNode(Node n)
this is a simple-minded implementation of containsNode that uses find
up to three times to locate the node.
|
QueryNode |
QueryNodeFactoryBase.createBind(Node node,
int i) |
QueryNode |
QueryNodeFactory.createBind(Node node,
int i) |
QueryNode |
QueryNodeFactoryBase.createBound(Node node,
int i) |
QueryNode |
QueryNodeFactory.createBound(Node node,
int i) |
QueryNode |
QueryNodeFactoryBase.createFixed(Node n) |
QueryNode |
QueryNodeFactory.createFixed(Node n) |
QueryNode |
QueryNodeFactoryBase.createJustBound(Node node,
int i) |
QueryNode |
QueryNodeFactory.createJustBound(Node node,
int i) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Domain> |
Query.executeBindings(Graph g,
List<Stage> stages,
Node[] results) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Domain> |
Query.executeBindings(Graph g,
Node[] results) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Domain> |
SimpleQueryEngine.executeBindings(List<Stage> outStages,
NamedGraphMap args,
Node[] nodes) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Domain> |
Query.executeBindings(List<Stage> outStages,
NamedGraphMap args,
Node[] nodes)
the standard "default" implementation of executeBindings.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Domain> |
Query.executeBindings(NamedGraphMap args,
Node[] nodes) |
Element |
PatternCompiler.fixed(Node value)
Method called to deliver a compiled Element constructed from a constant Node.
|
Element |
PatternStageCompiler.fixed(Node value) |
boolean |
Mapping.hasBound(Node v)
Answer true iff we have already bound v (predeclaration doesn't count)
|
int |
Mapping.indexOf(Node v)
get the index of a node in the mapping; undefined if the
node is not mapped.
|
int |
Mapping.lookUp(Node v)
get the index of a node in the mapping; return -1
if the node is not mapped.
|
abstract boolean |
Element.match(Domain d,
Node x)
Answer true if this Element matches x given the bindings in d.
|
boolean |
Bound.match(Domain d,
Node x)
Answer true iff the node
x matches the previously-seen value at
Donain[index]. |
boolean |
Bind.match(Domain d,
Node x)
Answer true after updating the domain to record the value this element binds.
|
boolean |
Fixed.match(Domain d,
Node x)
Answer true iff we are matched against a node with the same value as ours.
|
boolean |
QueryNode.match(Domain d,
Node x)
Answer true iff this QueryNode matches, in the context of the binding
Domain
d , the node x . |
boolean |
QueryNode.Bind.match(Domain d,
Node value) |
boolean |
QueryNode.JustBound.match(Domain d,
Node X) |
abstract boolean |
QueryNode.matchOrBind(Domain d,
Node x)
Optimisation: the action to be performed when matching a just-bound
variable or binding a newly-bound variable, or nothing for any other
kind of QueryNode.
|
boolean |
QueryNode.Fixed.matchOrBind(Domain d,
Node x) |
boolean |
QueryNode.Bind.matchOrBind(Domain d,
Node value) |
boolean |
QueryNode.JustBound.matchOrBind(Domain d,
Node x) |
boolean |
QueryNode.Bound.matchOrBind(Domain d,
Node x) |
boolean |
QueryNode.Any.matchOrBind(Domain d,
Node x) |
int |
Mapping.newIndex(Node v)
allocate an index to the node
v . |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.objectsFor(Graph g,
Node s,
Node p) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
QueryHandler.objectsFor(Node s,
Node p)
deliver an iterator over all the objects _o_ such that _(s, p, o)_ is in the
underlying graph; nulls count as wildcards.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.objectsFor(Node s,
Node p) |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.predicatesFor(Graph g,
Node s,
Node o) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
QueryHandler.predicatesFor(Node s,
Node o)
Answer an iterator over all the predicates
p such that
(s, p, o) is in the underlying graph. |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.predicatesFor(Node s,
Node o) |
BindingQueryPlan |
QueryHandler.prepareBindings(Query q,
Node[] variables)
prepare a plan for generating bindings given the query _q_ and the result
variables _variables_.
|
BindingQueryPlan |
SimpleQueryHandler.prepareBindings(Query q,
Node[] variables) |
void |
Domain.setElement(int i,
Node x) |
static com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.subjectsFor(Graph g,
Node p,
Node o) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
QueryHandler.subjectsFor(Node p,
Node o)
deliver an iterator over all the subjects _s_ such that _(s, p, o)_ is in the
underlying graph; nulls count as wildcards.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
SimpleQueryHandler.subjectsFor(Node p,
Node o) |
Modifier and Type | Method and Description |
---|---|
static QueryNode |
QueryNode.classify(QueryNodeFactory f,
Mapping map,
Set<Node> recent,
Node n)
Answer a QueryNode that classifies the argument node
n . |
Constructor and Description |
---|
Domain(Node[] value)
Initialise a Domain with a copy of a Node value array.
|
Fixed(Node x)
Initialise this element with its single matching value: remember that value.
|
Mapping(Node[] preDeclare)
Create a new mapping in which all variables are unbound and the variables
of
preDeclare will be allocated the first slots in the map in their
natural order. |
Query.UnboundVariableException(Node n) |
QueryNode.Bind(Node n,
int index) |
QueryNode.Bound(Node n,
int index) |
QueryNode.Fixed(Node n) |
QueryNode.JustBound(Node n,
int index) |
SimpleQueryPlan(Graph graph,
Query query,
Node[] variables) |
Modifier and Type | Method and Description |
---|---|
<T> boolean |
Profile.isSupported(Node n,
EnhGraph g,
Class<T> type)
Answer true if the given graph supports a view of this node as the given
language element, according to the semantic constraints of the profile.
|
Modifier and Type | Method and Description |
---|---|
RDFNode |
ModelGraphInterface.asRDFNode(Node n)
Answer an RDF node wrapping
n suitably; URI nodes
become Resources with the same URI, blank nodes become Resources
with URI null but the same AnonId, and literal nodes become Literals
with n as their value carrier. |
RDFNode |
ModelCon.getRDFNode(Node n)
|
Resource |
ModelGraphInterface.wrapAsResource(Node n) |
Constructor and Description |
---|
DoesNotReifyException(Node n) |
LiteralRequiredException(Node n) |
ResourceRequiredException(Node n) |
Modifier and Type | Method and Description |
---|---|
Node |
InfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
Node |
BaseInfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
Node |
TriplePattern.getObject()
Returns the object.
|
Node |
TriplePattern.getPredicate()
Returns the predicate.
|
Node |
TriplePattern.getSubject()
Returns the subject.
|
static Node |
ReasonerRegistry.makeDirect(Node node)
Return a property Node which represents the direct version of a
transitively closed property.
|
Modifier and Type | Method and Description |
---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
InfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.find(Node subject,
Node property,
Node object,
Graph param)
An extension of the Graph.find interface which allows the caller to
encode complex expressions in RDF and then refer to those expressions
within the query triple.
|
Node |
InfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
Node |
BaseInfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BaseInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
static Node |
ReasonerRegistry.makeDirect(Node node)
Return a property Node which represents the direct version of a
transitively closed property.
|
static String |
TriplePattern.simplePrintString(Node n)
Simplified printable name for a node
|
boolean |
InfGraph.testGlobalProperty(Node property)
A convenience version of getGlobalProperty which can only return
a boolean result.
|
boolean |
BaseInfGraph.testGlobalProperty(Node property)
A convenience version of getGlobalProperty which can only return
a boolean result.
|
Constructor and Description |
---|
TriplePattern(Node subject,
Node predicate,
Node object)
Constructor - builds a pattern from three nodes,
use Node_RuleVariables as variables, use a variable
with an empty name as a wildcard, can also use null
as a wildcard.
|
Modifier and Type | Class and Description |
---|---|
class |
Node_RuleVariable
A variation on the normal Node_Variable which support for value bindings.
|
Modifier and Type | Method and Description |
---|---|
Node |
Node_RuleVariable.deref()
Dereference a variable by following the reference chain.
|
Node[] |
Functor.getArgs()
Return the functor aguments as an array of nodes
|
Node[] |
Functor.getBoundArgs(BindingEnvironment env)
Return a new Node array containing the bound versions of this Functor's arguments
|
Node |
BindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Finder context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Graph context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
RuleContext context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
Node |
Node_RuleVariable.getRawBoundValue()
Return the raw value to which this variable is bound (via LP binding) with
no dereferencing.
|
Node |
BackwardRuleInfGraphI.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
FBRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
LPBackwardRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
static Node |
Util.makeDoubleNode(double value)
Construct a new double valued node
|
static Node |
Functor.makeFunctorNode(Functor f)
Wrap a functor as a Literal node
|
static Node |
Functor.makeFunctorNode(String name,
Node[] args)
Create a functor and wrap it up as a Literal node
|
static Node |
Util.makeIntNode(int value)
Construct a new integer valued node
|
static Node |
Util.makeList(Node[] nodes,
Graph graph)
Construct an RDF list from the given array of nodes and assert it
in the graph returning the head of the list.
|
static Node |
Util.makeLongNode(long value)
Construct a new long valued node
|
Node |
BasicFBReifier.reifyAs(Node n,
Triple t) |
Modifier and Type | Method and Description |
---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
BasicFBReifier.allNodes() |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
BasicFBReifier.allNodes(Triple t) |
static List<Node> |
Util.convertList(Node root,
RuleContext context)
Convert an (assumed well formed) RDF list to a java list of Nodes
|
Modifier and Type | Method and Description |
---|---|
boolean |
BindingEnvironment.bind(Node var,
Node value)
Bind a variable in the current envionment to the given value.
|
boolean |
Builtin.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
ValidityReport.Report |
FBRuleInfGraph.checkLiteral(Node prop,
Triple triple)
Check a given literal value for a property against the set of
known range constraints for it.
|
static int |
Util.compareInstants(Node n1,
Node n2)
Compare two time Instant nodes.
|
static int |
Util.compareNumbers(Node n1,
Node n2)
Compare two numeric nodes.
|
boolean |
RuleContext.contains(Node s,
Node p,
Node o)
Return true if the triple pattern is already in either the graph or the stack.
|
static List<Node> |
Util.convertList(Node root,
RuleContext context)
Convert an (assumed well formed) RDF list to a java list of Nodes
|
com.hp.hpl.jena.util.iterator.ClosableIterator<Triple> |
RuleContext.find(Node s,
Node p,
Node o)
In some formulations the context includes deductions that are not yet
visible to the underlying graph but need to be checked for.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
ForwardRuleInfGraphI.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern.
|
Node |
BindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node.
|
static int |
Util.getIntValue(Node n)
Return the integer value of a literal node
|
static Node |
Util.getPropValue(Node root,
Node prop,
Finder context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
Graph context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
static Node |
Util.getPropValue(Node root,
Node prop,
RuleContext context)
Helper - returns the (singleton) value for the given property on the given
root node in the data graph.
|
Node |
BackwardRuleInfGraphI.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
FBRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Node |
LPBackwardRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value.
|
Triple |
BasicFBReifier.getTriple(Node n) |
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
FBRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
BasicForwardRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
LPBackwardRuleInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
boolean |
BasicFBReifier.hasTriple(Node n) |
void |
Builtin.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
FBRuleInfGraph.hideNode(Node n)
Called to flag that a node should be hidden from external queries.
|
static boolean |
Functor.isFunctor(Node n)
tests that a given Node represents a functor
|
static boolean |
Util.isInstant(Node n)
Check whether a Node is an Instant (DateTime) value
|
static boolean |
Util.isNumeric(Node n)
Check whether a Node is a numeric (integer) value
|
static Node |
Functor.makeFunctorNode(String name,
Node[] args)
Create a functor and wrap it up as a Literal node
|
static Node |
Util.makeList(Node[] nodes,
Graph graph)
Construct an RDF list from the given array of nodes and assert it
in the graph returning the head of the list.
|
Node |
BasicFBReifier.reifyAs(Node n,
Triple t) |
void |
BasicFBReifier.remove(Node n,
Triple t) |
static boolean |
Node_RuleVariable.sameNodeAs(Node n,
Node m)
Compare two nodes, taking into account variable indices.
|
void |
FBRuleInfGraph.setTabled(Node predicate)
Set a predicate to be tabled/memoized by the LP engine.
|
void |
LPBackwardRuleInfGraph.setTabled(Node predicate)
Set a predicate to be tabled/memoized by the LP engine.
|
void |
Node_RuleVariable.simpleBind(Node node)
Binds a value to the brule version of the variable.
|
void |
LPBackwardRuleReasoner.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force
the goal to be tabled.
|
void |
FBRuleReasoner.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force
the goal to be tabled.
|
Constructor and Description |
---|
Functor(String name,
Node[] args)
Constructor.
|
Constructor and Description |
---|
Functor(String name,
List<Node> args)
Constructor.
|
Functor(String name,
List<Node> args,
BuiltinRegistry registry)
Constructor
|
Modifier and Type | Method and Description |
---|---|
Node |
BaseBuiltin.getArg(int n,
Node[] args,
RuleContext context)
Return the n'th argument node after dererencing by what ever type of
rule engine binding environment is appropriate.
|
Modifier and Type | Method and Description |
---|---|
boolean |
ListContains.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
StrConcat.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Min.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Now.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Bound.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
LE.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotFunctor.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Difference.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
UriConcat.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Hide.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotBNode.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
MakeSkolem.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
LessThan.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Quotient.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotDType.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListNotContains.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NoValue.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListEntry.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsBNode.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsDType.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
MakeInstance.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsLiteral.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListNotEqual.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Max.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
GE.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
GreaterThan.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
ListLength.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
BaseBuiltin.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
IsFunctor.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Product.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
AddOne.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
MakeTemp.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Regex.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Equal.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Print.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
NotLiteral.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Unbound.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
CountLiteralValues.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
boolean |
Sum.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
Node |
BaseBuiltin.getArg(int n,
Node[] args,
RuleContext context)
Return the n'th argument node after dererencing by what ever type of
rule engine binding environment is appropriate.
|
void |
ListMapAsSubject.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
Drop.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
Hide.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
ListMapAsObject.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
Table.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
void |
AssertDisjointPairs.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
BaseBuiltin.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
Print.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
TableAll.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body.
|
void |
Remove.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
void |
MakeTemp.headAction(Node[] args,
RuleContext context)
This method is invoked when the builtin is called in a rule head.
|
static boolean |
IsDType.isTypeOK(Node val,
Node dt)
Check if a literal value node is a legal value for the given datatype.
|
void |
Print.print(Node[] args,
int length,
RuleContext context)
Print a node list to stdout
|
Modifier and Type | Field and Description |
---|---|
static Node |
TransitiveReasoner.directSubClassOf
The direct (minimal) version of the subClassOf property
|
static Node |
TransitiveEngine.directSubClassOf
The direct (minimal) version of the subClassOf property
|
static Node |
TransitiveReasoner.directSubPropertyOf
The direct (minimal) version of the subPropertyOf property
|
static Node |
TransitiveEngine.directSubPropertyOf
The direct (minimal) version of the subPropertyOf property
|
static Node |
TransitiveReasoner.subClassOf
The normal subClassOf property
|
static Node |
TransitiveEngine.subClassOf
The normal subClassOf property
|
static Node |
TransitiveReasoner.subPropertyOf
The normal subPropertyOf property
|
static Node |
TransitiveEngine.subPropertyOf
The normal subPropertyOf property
|
Modifier and Type | Method and Description |
---|---|
Node |
TransitiveGraphCache.getClosedPredicate()
Returns the closedPredicate.
|
Node |
TransitiveGraphCache.getDirectPredicate()
Returns the directPredicate.
|
Modifier and Type | Method and Description |
---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Node> |
TransitiveGraphCache.listAllSubjects()
Return an iterator over all registered subject nodes
|
Modifier and Type | Method and Description |
---|---|
boolean |
TransitiveGraphCache.cacheAll(Finder graph,
Node predicate)
Cache all instances of the given predicate which are
present in the given Graph.
|
boolean |
TransitiveEngine.checkOccurance(Node prop,
Graph graph)
Test if there are any usages of prop within the given graph.
|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
TransitiveInfGraph.graphBaseFind(Node subject,
Node property,
Node object)
Returns an iterator over Triples.
|
boolean |
TransitiveGraphCache.isSubject(Node node)
Return true if the given Node is registered as a subject node
|
Constructor and Description |
---|
TransitiveGraphCache(Node directPredicate,
Node closedPredicate)
Constructor - create a new cache to hold the given relation information.
|
Modifier and Type | Method and Description |
---|---|
com.hp.hpl.jena.util.iterator.ExtendedIterator<Triple> |
RandomOrderGraph.find(Node s,
Node p,
Node o) |
Constructor and Description |
---|
AlreadyReifiedException(Node n) |
CannotReifyException(Node n) |
Modifier and Type | Method and Description |
---|---|
Node[] |
QueryMapper.getVariables() |
Node |
QueryMapper.toQueryNode(RDFNode rn) |
Node[] |
QueryMapper.toQueryVariables(Resource[] vars) |
Modifier and Type | Method and Description |
---|---|
static RDFNode |
ModelQueryUtil.asRDF(Model m,
Node n) |
static String |
PrintUtil.print(Node node)
Return a simplified print string for a Node.
|
Modifier and Type | Field and Description |
---|---|
static Node |
RDF.Nodes.Alt |
static Node |
RDF.Nodes.Bag |
static Node |
RDFS.Nodes.Class |
static Node |
RDFS.Nodes.comment |
static Node |
RDFS.Nodes.Container |
static Node |
RDFS.Nodes.ContainerMembershipProperty |
static Node |
RDFS.Nodes.Datatype |
static Node |
RDFS.Nodes.domain |
static Node |
RDF.Nodes.first |
static Node |
RDFS.Nodes.isDefinedBy |
static Node |
RDFS.Nodes.label |
static Node |
RDF.Nodes.List |
static Node |
RDFS.Nodes.Literal |
static Node |
RDFS.Nodes.member |
static Node |
RDF.Nodes.nil |
static Node |
RDF.Nodes.object |
static Node |
RDF.Nodes.predicate |
static Node |
RDF.Nodes.Property |
static Node |
RDFS.Nodes.range |
static Node |
RDFS.Nodes.Resource |
static Node |
RDF.Nodes.rest |
static Node |
RDFS.Nodes.seeAlso |
static Node |
RDF.Nodes.Seq |
static Node |
RDF.Nodes.Statement |
static Node |
RDFS.Nodes.subClassOf |
static Node |
RDF.Nodes.subject |
static Node |
RDFS.Nodes.subPropertyOf |
static Node |
RDF.Nodes.type |
static Node |
RDF.Nodes.value |
Copyright ? 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Hewlett-Packard Development Company, LP