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.rdfsReasoner1	This package contains an example RDFS reasoner.
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.util	Miscellaneous collection of utility classes.

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
class	Node_Blank
class	Node_Concrete This is the superclass for "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
class	Node_URI
class	Node_Variable

Fields in com.hp.hpl.jena.graph declared as Node

static Node	Reifier.type
static Node	Reifier.subject
static Node	Reifier.predicate
static Node	Reifier.object
static Node	Reifier.Statement
static Node	Node.ANY The canonical instance of Node_ANY; no-one else need use the constructor.

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(com.hp.hpl.jena.shared.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.

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.
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) return 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)

Reifier.CannotReifyException(Node n)

Reifier.AlreadyReifiedException(Node n)

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
static Node	Query.S
static Node	Query.P
static Node	Query.O
static Node	Query.X
static Node	Query.Y
static Node	Query.Z
static Node	Query.NE

Methods in com.hp.hpl.jena.graph.query that return Node

Node	ValuatorVariable.eval(Domain d) return the value in our slot [as passed in to the constructor]
Node	ValuatorConst.eval(Domain d) return the value specified when constructed
Node	Valuator.eval(Domain d) return the value of this valuator in the context of _d_
Node	Relation.valueL(Domain d) evaluate the left operand against the domain _d_
Node	Relation.valueR(Domain d) evaluate the right operand against the domain _d_
Node	Fixed.getValue()
Node	Fixed.asNode(Domain d)
Node	Element.asNode(Domain d)
Node	Bound.asNode(Domain d)

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.
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)
Query	Query.addMatch(java.lang.String name, Node S, Node P, Node O)
Query	Query.addConstraint(Node S, Node P, Node O)
ExtendedIterator	Query.executeBindings(Graph g, Node[] results)
ExtendedIterator	Query.executeBindings(Query.ArgMap 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)
Element	PatternCompiler.bound(Node n, int index)
Element	PatternCompiler.bind(Node n, int index)
int	Mapping.indexOf(Node v) get the index of a node in the mapping; undefined if the node is not mapped.
int	Mapping.newIndex(Node v) allocate an index to the node _v_.
boolean	Mapping.maps(Node v)
boolean	Fixed.accepts(Domain d, Node x)
boolean	Element.accepts(Domain d, Node n)
boolean	Bound.accepts(Domain d, Node x)
boolean	Bind.accepts(Domain d, Node x)

Constructors in com.hp.hpl.jena.graph.query with parameters of type Node

ValuatorConst(Node X)
construct a valuator that remembers the value _X_

SimpleQueryPlan(Graph graph, Query query, Node[] variables)

Fixed(Node x)

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.
Node	RDFNode.asNode() a presentation-layer RDFNode is build on top of an SPI-layer Node; get it.

Methods in com.hp.hpl.jena.rdf.model with parameters of type Node

RDFNode

ModelCon.getRDFNode(Node n) create or find a Resource from a graph Node.

Constructors in com.hp.hpl.jena.rdf.model with parameters of type Node

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.rdfsReasoner1

Fields in com.hp.hpl.jena.reasoner.rdfsReasoner1 declared as Node

static Node	RDFSReasoner.domainP Deprecated. The domain property
static Node	RDFSReasoner.rangeP Deprecated. The range property

Methods in com.hp.hpl.jena.reasoner.rdfsReasoner1 that return Node

static Node

BRWRule.parseNode(java.lang.String token) Assistant method to makeRule than parses a token as a node.

Methods in com.hp.hpl.jena.reasoner.rdfsReasoner1 with parameters of type Node

boolean

RDFSInfGraph.isProperty(Node prop) Variant on find called by special backward rules that need to list check for a specific preregistered property.

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.util

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.