|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use Node | |
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.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.rdql | RDQL - A query language for Jena. |
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. |
Uses of Node in com.hp.hpl.jena.db |
Methods in com.hp.hpl.jena.db that return Node | |
Node |
GraphRDB.getNode()
Returns the Node for this model in the system properties graph. |
Methods in com.hp.hpl.jena.db with parameters of type Node | |
boolean |
GraphRDB.contains(Node s,
Node p,
Node o)
|
Uses of Node in com.hp.hpl.jena.enhanced |
Methods in com.hp.hpl.jena.enhanced that return Node | |
Node |
EnhNode.asNode()
Answer the graph node that this enhanced node wraps |
Methods in com.hp.hpl.jena.enhanced with parameters of type Node | |
Polymorphic |
Personality.newInstance(java.lang.Class interf,
Node n,
Polymorphic 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 |
abstract boolean |
Implementation.canWrap(Node node,
EnhGraph eg)
true iff wrapping (node, eg) would succeed. |
EnhNode |
EnhGraph.getNodeAs(Node n,
java.lang.Class interf)
Answer an enhanced node that wraps the given node and conforms to the given interface type. |
Constructors in com.hp.hpl.jena.enhanced with parameters of type Node | |
EnhNode(Node n,
EnhGraph g)
|
Uses of Node in com.hp.hpl.jena.graph |
Subclasses of Node in com.hp.hpl.jena.graph | |
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
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_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. |
Fields in com.hp.hpl.jena.graph declared as Node | |
static Node |
Node.ANY
The canonical instance of Node_ANY; no-one else need use the constructor. |
static Node |
Node.NULL
The canonical NULL. |
Methods in com.hp.hpl.jena.graph that return Node | |
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 |
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 |
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.getSubject()
|
Node |
Triple.getPredicate()
|
Node |
Triple.getObject()
|
Node |
Triple.getMatchSubject()
|
Node |
Triple.getMatchPredicate()
|
Node |
Triple.getMatchObject()
|
Node |
Reifier.reifyAs(Node n,
Triple t)
note the triple _t_ as reified using _n_ as its representing node. |
static Node |
Node.create(java.lang.String x)
Returns a Node described by the string, primarily for testing purposes. |
static Node |
Node.create(PrefixMapping pm,
java.lang.String x)
As for create(String), but the PrefixMapping used to translate URI strings is an additional argument. |
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.createURI(java.lang.String uri)
make a URI node with the specified URIref string |
static Node |
Node.createAnon()
make a blank node with a fresh anon id |
static Node |
Node.createVariable(java.lang.String name)
make a variable node with a given name |
static Node |
Node.createLiteral(java.lang.String lit,
java.lang.String lang,
boolean isXml)
make a literal with specified language and XMLishness. |
static Node |
Node.createLiteral(java.lang.String lex,
java.lang.String lang,
RDFDatatype dtype)
Build a typed literal node from its lexical form. |
static Node |
Node.create(com.hp.hpl.jena.graph.Node.NodeMaker maker,
java.lang.Object label)
We object strongly to null labels: for example, they make .equals flaky. |
Node |
FrontsNode.asNode()
Answer the Node associated with this object. |
Methods in com.hp.hpl.jena.graph with parameters of type Node | |
boolean |
Triple.matches(Node s,
Node p,
Node o)
|
boolean |
Triple.subjectMatches(Node s)
|
boolean |
Triple.predicateMatches(Node p)
|
boolean |
Triple.objectMatches(Node o)
|
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)
|
Node |
Reifier.reifyAs(Node n,
Triple t)
note the triple _t_ as reified using _n_ as its representing node. |
boolean |
Reifier.hasTriple(Node n)
true iff _n_ is associated with some triple. |
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 |
Node_Literal.matches(Node x)
|
boolean |
Node_ANY.matches(Node other)
|
boolean |
Node.matches(Node other)
Answer true iff this node accepts the other one as a match. |
Graph |
GraphMaker.getDescription(Node root)
|
Graph |
GraphMaker.addDescription(Graph desc,
Node self)
Add the description of this GraphMaker to the description graph desc, under the name self. |
ExtendedIterator |
Graph.find(Node s,
Node p,
Node o)
Returns an iterator over Triple. |
boolean |
Graph.contains(Node s,
Node p,
Node o)
Answer true iff the graph contains a triple matching (s, p, o). |
Triple |
GetTriple.getTriple(Node n)
Answer the triple associated with the node n . |
Constructors in com.hp.hpl.jena.graph with parameters of type Node | |
Triple(Node s,
Node p,
Node o)
|
Uses of Node in com.hp.hpl.jena.graph.query |
Fields in com.hp.hpl.jena.graph.query declared as Node | |
static Node |
Query.ANY
A convenient synonym for Node.ANY, used in a match to match anything. |
static Node |
Query.S
A query variable called "S". |
static Node |
Query.P
A query variable called "P". |
static Node |
Query.O
A query variable called "O". |
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". |
Methods in com.hp.hpl.jena.graph.query that return Node | |
Node |
Fixed.asNodeMatch(Domain d)
Answer the Node we represent given the variable-bindings Domain. |
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. |
Methods in com.hp.hpl.jena.graph.query with parameters of type Node | |
BindingQueryPlan |
SimpleQueryHandler.prepareBindings(Query q,
Node[] variables)
|
ExtendedIterator |
SimpleQueryHandler.objectsFor(Node s,
Node p)
|
ExtendedIterator |
SimpleQueryHandler.subjectsFor(Node p,
Node o)
|
boolean |
SimpleQueryHandler.containsNode(Node n)
this is a simple-minded implementation of containsNode that uses find up to three times to locate the node. |
ExtendedIterator |
SimpleQueryEngine.executeBindings(java.util.List outStages,
NamedGraphMap args,
Node[] nodes)
|
BindingQueryPlan |
QueryHandler.prepareBindings(Query q,
Node[] variables)
prepare a plan for generating bindings given the query _q_ and the result variables _variables_. |
ExtendedIterator |
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. |
ExtendedIterator |
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. |
boolean |
QueryHandler.containsNode(Node n)
true iff the graph contains a triple in which n appears somewhere. |
Query |
Query.addMatch(Node s,
Node p,
Node o)
Add an (S, P, O) match to the query's collection of match triples. |
Query |
Query.addMatch(java.lang.String name,
Node s,
Node p,
Node o)
Add an (S, P, O) match triple to this query to match against the graph labelled with name . |
ExtendedIterator |
Query.executeBindings(Graph g,
Node[] results)
|
ExtendedIterator |
Query.executeBindings(Graph g,
java.util.List stages,
Node[] results)
|
ExtendedIterator |
Query.executeBindings(NamedGraphMap args,
Node[] nodes)
|
ExtendedIterator |
Query.executeBindings(java.util.List outStages,
NamedGraphMap args,
Node[] nodes)
the standard "default" implementation of executeBindings. |
Element |
PatternStageCompiler.fixed(Node value)
|
Element |
PatternStageCompiler.bound(Node n,
int index)
|
Element |
PatternStageCompiler.bind(Node n,
int index)
|
Element |
PatternCompiler.fixed(Node value)
Method called to deliver a compiled Element constructed from a constant Node. |
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 |
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. |
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. |
int |
Mapping.newIndex(Node v)
allocate an index to the node _v_. |
boolean |
Mapping.hasBound(Node v)
Answer true iff we have already bound v (predeclaration doesn't count) |
boolean |
Fixed.match(Domain d,
Node x)
Answer true iff we are matched against a node with the same value as ours. |
abstract boolean |
Element.match(Domain d,
Node x)
Answer true if this Element matches x given the bindings in d. |
void |
Domain.setElement(int i,
Node x)
|
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. |
Constructors in com.hp.hpl.jena.graph.query with parameters of type Node | |
SimpleQueryPlan(Graph graph,
Query query,
Node[] variables)
|
|
Query.UnboundVariableException(Node n)
|
|
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. |
|
Fixed(Node x)
Initialise this element with its single matching value: remember that value. |
|
Domain(Node[] value)
Initialise a Domain with a copy of a Node value array. |
Uses of Node in com.hp.hpl.jena.ontology |
Methods in com.hp.hpl.jena.ontology with parameters of type Node | |
boolean |
Profile.isSupported(Node n,
EnhGraph g,
java.lang.Class 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. |
Uses of Node in com.hp.hpl.jena.rdf.model |
Methods in com.hp.hpl.jena.rdf.model that return Node | |
Node |
Resource.getNode()
every Resource overlays a Node; fetch that Node. |
Methods in com.hp.hpl.jena.rdf.model with parameters of type Node | |
RDFNode |
ModelCon.getRDFNode(Node n)
Create or find an RDFNode (a Resource or a Literal )
from a graph Node. |
Constructors in com.hp.hpl.jena.rdf.model with parameters of type Node | |
ResourceRequiredException(Node n)
|
|
LiteralRequiredException(Node n)
|
|
DoesNotReifyException(Node n)
|
Uses of Node in com.hp.hpl.jena.rdql |
Methods in com.hp.hpl.jena.rdql with parameters of type Node | |
void |
Query.addTriplePattern(Node s,
Node p,
Node o)
|
Uses of Node in com.hp.hpl.jena.reasoner |
Methods in com.hp.hpl.jena.reasoner that return Node | |
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. |
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. |
Methods in com.hp.hpl.jena.reasoner with parameters of type Node | |
static java.lang.String |
TriplePattern.simplePrintString(Node n)
Simplified printable name for a node |
static Node |
ReasonerRegistry.makeDirect(Node node)
Return a property Node which represents the direct version of a transitively closed property. |
Node |
InfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph. |
boolean |
InfGraph.testGlobalProperty(Node property)
A convenience version of getGlobalProperty which can only return a boolean result. |
ExtendedIterator |
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. |
Node |
BaseInfGraph.getGlobalProperty(Node property)
Test a global boolean property of the graph. |
boolean |
BaseInfGraph.testGlobalProperty(Node property)
A convenience version of getGlobalProperty which can only return a boolean result. |
ExtendedIterator |
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. |
ExtendedIterator |
BaseInfGraph.find(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
boolean |
BaseInfGraph.contains(Node s,
Node p,
Node o)
Test if the graph contains the given triple. |
Constructors in com.hp.hpl.jena.reasoner with parameters of type Node | |
TriplePattern(Node subject,
Node predicate,
Node object)
Constructor - builds a pattern from three nodes, use Node_Variables as variables, use a variable with an empty name as a wildcard, can also use null as a wildcard. |
Uses of Node in com.hp.hpl.jena.reasoner.rulesys |
Subclasses of Node in com.hp.hpl.jena.reasoner.rulesys | |
class |
Node_RuleVariable
A variation on the normal Node_Variable which support for value bindings. |
Methods in com.hp.hpl.jena.reasoner.rulesys that return 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. |
static Node |
Util.makeIntNode(int value)
Construct a new integer valued node |
static Node |
Util.makeLongNode(long value)
Construct a new long valued node |
static Node |
Util.makeDoubleNode(double value)
Construct a new double 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. |
Node |
Node_RuleVariable.deref()
Dereference a variable by following the reference chain. |
Node |
Node_RuleVariable.getRawBoundValue()
Return the raw value to which this variable is bound (via LP binding) with no dereferencing. |
Node |
LPBackwardRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value. |
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 |
static Node |
Functor.makeFunctorNode(java.lang.String name,
Node[] args)
Create a functor and wrap it up as a Literal node |
static Node |
Functor.makeFunctorNode(Functor f)
Wrap a functor as a Literal node |
Node |
FBRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value. |
Node |
BindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node. |
Node |
BackwardRuleInfGraphI.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value. |
Methods in com.hp.hpl.jena.reasoner.rulesys with parameters of type Node | |
static boolean |
Util.isNumeric(Node n)
Check whether a Node is a numeric (integer) value |
static int |
Util.getIntValue(Node n)
Return the integer value of a literal node |
static int |
Util.compareNumbers(Node n1,
Node n2)
Compare two numeric nodes. |
static boolean |
Util.isInstant(Node n)
Check whether a Node is an Instant (DateTime) value |
static int |
Util.compareInstants(Node n1,
Node n2)
Compare two time Instant nodes. |
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. |
static java.util.List |
Util.convertList(Node root,
RuleContext context)
Convert an (assumed well formed) RDF list to a java list of Nodes |
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. |
boolean |
RuleContext.contains(Node s,
Node p,
Node o)
Return true if the triple pattern is already in either the graph or the stack. |
ClosableIterator |
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. |
ValidityReport.Report |
RDFSRuleInfGraph.checkLiteral(Node prop,
Node value)
Check a given literal value for a property against the set of known range constraints for it. |
void |
Node_RuleVariable.simpleBind(Node node)
Binds a value to the brule version of the variable. |
static boolean |
Node_RuleVariable.sameNodeAs(Node n,
Node m)
Compare two nodes, taking into account variable indices. |
void |
LPBackwardRuleReasoner.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force the goal to be tabled. |
ExtendedIterator |
LPBackwardRuleInfGraph.find(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
void |
LPBackwardRuleInfGraph.setTabled(Node predicate)
Set a predicate to be tabled/memoized by the LP engine. |
Node |
LPBackwardRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value. |
static boolean |
Functor.isFunctor(Node n)
tests that a given Node represents a functor |
static Node |
Functor.makeFunctorNode(java.lang.String name,
Node[] args)
Create a functor and wrap it up as a Literal node |
ExtendedIterator |
ForwardRuleInfGraphI.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern. |
void |
FBRuleReasoner.tablePredicate(Node predicate)
Register an RDF predicate as one whose presence in a goal should force the goal to be tabled. |
ExtendedIterator |
FBRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern. |
void |
FBRuleInfGraph.setTabled(Node predicate)
Set a predicate to be tabled/memoized by the LP engine. |
Node |
FBRuleInfGraph.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value. |
ExtendedIterator |
FBRuleInfGraph.find(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
void |
FBRuleInfGraph.hideNode(Node n)
Called to flag that a node should be hidden from external queries. |
boolean |
Builtin.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body. |
void |
Builtin.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
Node |
BindingEnvironment.getGroundVersion(Node node)
Return the most ground version of the node. |
boolean |
BindingEnvironment.bind(Node var,
Node value)
Bind a variable in the current envionment to the given value. |
ExtendedIterator |
BasicForwardRuleInfGraph.find(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
ExtendedIterator |
BasicForwardRuleInfGraph.findDataMatches(Node subject,
Node predicate,
Node object)
Search the combination of data and deductions graphs for the given triple pattern. |
Node |
BackwardRuleInfGraphI.getTemp(Node instance,
Node prop,
Node pclass)
Retrieve or create a bNode representing an inferred property value. |
Constructors in com.hp.hpl.jena.reasoner.rulesys with parameters of type Node | |
Functor(java.lang.String name,
Node[] args)
Constructor. |
Uses of Node in com.hp.hpl.jena.reasoner.rulesys.builtins |
Methods in com.hp.hpl.jena.reasoner.rulesys.builtins that return Node | |
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. |
Methods in com.hp.hpl.jena.reasoner.rulesys.builtins with parameters of type Node | |
boolean |
Unbound.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body. |
void |
TableAll.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body. |
void |
Table.headAction(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. |
void |
Remove.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
boolean |
Product.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. |
void |
Print.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
void |
Print.print(Node[] args,
int length,
RuleContext context)
Print a node list to stdout |
boolean |
NoValue.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 |
NotFunctor.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 |
NotDType.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 |
Min.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 |
MakeTemp.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body. |
void |
MakeTemp.headAction(Node[] args,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
boolean |
MakeInstance.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 |
ListNotContains.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body. |
void |
ListMapAsSubject.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. |
boolean |
ListLength.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 |
ListContains.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 |
LE.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 |
IsFunctor.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. |
static boolean |
IsDType.isTypeOK(Node val,
Node dt)
Check if a literal value node is a legal value for the given datatype. |
boolean |
IsBNode.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. |
void |
Hide.headAction(Node[] args,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
boolean |
GreaterThan.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 |
Equal.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 |
Bound.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. |
void |
BaseBuiltin.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
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 |
AssertDisjointPairs.headAction(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule head. |
boolean |
AddOne.bodyCall(Node[] args,
int length,
RuleContext context)
This method is invoked when the builtin is called in a rule body. |
Uses of Node in com.hp.hpl.jena.reasoner.transitiveReasoner |
Fields in com.hp.hpl.jena.reasoner.transitiveReasoner declared as Node | |
static Node |
TransitiveReasoner.directSubPropertyOf
The direct (minimal) version of the subPropertyOf property |
static Node |
TransitiveReasoner.directSubClassOf
The direct (minimal) version of the subClassOf property |
static Node |
TransitiveReasoner.subPropertyOf
The normal subPropertyOf property |
static Node |
TransitiveReasoner.subClassOf
The normal subClassOf property |
static Node |
TransitiveEngine.directSubPropertyOf
The direct (minimal) version of the subPropertyOf property |
static Node |
TransitiveEngine.directSubClassOf
The direct (minimal) version of the subClassOf property |
static Node |
TransitiveEngine.subPropertyOf
The normal subPropertyOf property |
static Node |
TransitiveEngine.subClassOf
The normal subClassOf property |
Methods in com.hp.hpl.jena.reasoner.transitiveReasoner that return Node | |
Node |
TransitiveGraphCache.getClosedPredicate()
Returns the closedPredicate. |
Node |
TransitiveGraphCache.getDirectPredicate()
Returns the directPredicate. |
Methods in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Node | |
ExtendedIterator |
TransitiveInfGraph.find(Node subject,
Node property,
Node object)
Returns an iterator over Triples. |
void |
TransitiveGraphCache.addRelation(Node start,
Node end)
Register a new relation instance in the cache |
void |
TransitiveGraphCache.removeRelation(Node start,
Node end)
Remove an instance of a relation from the cache. |
boolean |
TransitiveGraphCache.cacheAll(Finder graph,
Node predicate)
Cache all instances of the given predicate which are present in the given Graph. |
boolean |
TransitiveGraphCache.isProperty(Node node)
Return true if the given Node is registered as a property |
boolean |
TransitiveEngine.checkOccurance(Node prop,
Graph graph)
Test if there are any usages of prop within the given graph. |
static boolean |
TransitiveEngine.checkOccuranceUtility(Node prop,
Graph graph,
TransitiveGraphCache spCache)
Test if there are any usages of prop within the given graph. |
Constructors in com.hp.hpl.jena.reasoner.transitiveReasoner with parameters of type Node | |
TransitiveGraphCache(Node directPredicate,
Node closedPredicate)
Constructor - create a new cache to hold the given relation information. |
Uses of Node in com.hp.hpl.jena.shared |
Methods in com.hp.hpl.jena.shared with parameters of type Node | |
ExtendedIterator |
RandomOrderGraph.find(Node s,
Node p,
Node o)
|
Constructors in com.hp.hpl.jena.shared with parameters of type Node | |
CannotReifyException(Node n)
|
|
AlreadyReifiedException(Node n)
|
Uses of Node in com.hp.hpl.jena.util |
Methods in com.hp.hpl.jena.util that return Node | |
Node[] |
QueryMapper.getVariables()
|
Node[] |
QueryMapper.toQueryVariables(Resource[] vars)
|
Node |
QueryMapper.toQueryNode(RDFNode rn)
|
Methods in com.hp.hpl.jena.util with parameters of type Node | |
static java.lang.String |
PrintUtil.print(Node node)
Return a simplified print string for a Node. |
static RDFNode |
ModelQueryUtil.asRDF(com.hp.hpl.jena.rdf.model.impl.ModelCom m,
Node n)
|
Uses of Node in com.hp.hpl.jena.vocabulary |
Fields in com.hp.hpl.jena.vocabulary declared as Node | |
static Node |
RDFS.Nodes.Class
|
static Node |
RDFS.Nodes.Datatype
|
static Node |
RDFS.Nodes.ConstraintProperty
|
static Node |
RDFS.Nodes.Container
|
static Node |
RDFS.Nodes.ContainerMembershipProperty
|
static Node |
RDFS.Nodes.Literal
|
static Node |
RDFS.Nodes.Resource
|
static Node |
RDFS.Nodes.comment
|
static Node |
RDFS.Nodes.domain
|
static Node |
RDFS.Nodes.label
|
static Node |
RDFS.Nodes.isDefinedBy
|
static Node |
RDFS.Nodes.range
|
static Node |
RDFS.Nodes.seeAlso
|
static Node |
RDFS.Nodes.subClassOf
|
static Node |
RDFS.Nodes.subPropertyOf
|
static Node |
RDFS.Nodes.member
|
static Node |
RDF.Nodes.Alt
|
static Node |
RDF.Nodes.Bag
|
static Node |
RDF.Nodes.Property
|
static Node |
RDF.Nodes.Seq
|
static Node |
RDF.Nodes.Statement
|
static Node |
RDF.Nodes.List
|
static Node |
RDF.Nodes.nil
|
static Node |
RDF.Nodes.first
|
static Node |
RDF.Nodes.rest
|
static Node |
RDF.Nodes.subject
|
static Node |
RDF.Nodes.predicate
|
static Node |
RDF.Nodes.object
|
static Node |
RDF.Nodes.type
|
static Node |
RDF.Nodes.value
|
Methods in com.hp.hpl.jena.vocabulary that return Node | |
static Node |
JMS.styleAsJMS(ReificationStyle style)
Answer the Node which corresponds to the supplied reification style. |
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |