Uses of Class
com.hp.hpl.jena.graph.Node

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.
 



Copyright © 2000-2003 Hewlett-Packard. All Rights Reserved.