com.hp.hpl.jena.graph
Class Node

java.lang.Object
  com.hp.hpl.jena.graph.Node

Direct Known Subclasses:

Node_Concrete, Node_Fluid

public abstract class Node

extends java.lang.Object

Author:

Jeremy Carroll and Chris Dollin
A Node has five subtypes: Node_Blank, Node_Anon, Node_URI, Node_Variable, and Node_ANY. Nodes are only constructed by the node factory methods, and they will attempt to re-use existing nodes with the same label if they are recent enough.

Field Summary

static Node

ANY The canonical instance of Node_ANY; no-one else need use the constructor.

Method Summary

static void	cache(boolean wantCache) provided only for testing purposes.
static 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.
static 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	create(java.lang.String x) Returns a Node described by the string, primarily for testing purposes.
static Node	createAnon() make a blank node with a fresh anon id
static Node	createAnon(AnonId id) make a blank node with the specified label
static Node	createLiteral(com.hp.hpl.jena.graph.impl.LiteralLabel lit) make a literal node with the specified literal value
static Node	createLiteral(java.lang.String lit, java.lang.String lang, boolean isXml) make a literal with specified language and XMLishness.
static Node	createLiteral(java.lang.String lex, java.lang.String lang, RDFDatatype dtype) Build a typed literal node from its lexical form.
static Node	createURI(java.lang.String uri) make a URI node with the specified URIref string
static Node	createVariable(java.lang.String name) make a variable node with a given name
abstract boolean	equals(java.lang.Object o) Nodes only equal other Nodes that have equal labels.
AnonId	getBlankNodeId() get the blank node id if the node is blank, otherwise die horribly
com.hp.hpl.jena.graph.impl.LiteralLabel	getLiteral() get the literal value of a literal node, otherwise die horribly
java.lang.String	getName() get a variable nodes name, otherwise die horribly
Triple	getTriple(GetTriple r) get the triple associated with this node; if no direct association, use the triple-getter _r_.
java.lang.String	getURI() get the URI of this node if it has one, else die horribly
int	hashCode()
boolean	isBlank() is this a blank node - overridden in Node_Blank
abstract boolean	isConcrete() Answer true iff this node is concrete, ie not variable, ie URI, blank, or literal.
boolean	isLiteral() is this a literal node - overridden in Node_Literal
boolean	isURI() is this a URI node - overridden in Node_URI
boolean	isVariable() is this a variable node - overridden in Node_Variable
boolean	matches(Node other) Answer true iff this node accepts the other one as a match.
static void	nullLiteralsGenerateWarnings()
boolean	sameValueAs(java.lang.Object o) Test that two nodes are semantically equivalent.
java.lang.String	toString() Return the N-Triple representation of this node. hedgehog hack: just use the label's string.
abstract java.lang.Object	visitWith(NodeVisitor v) Visit a Node and dispatch on it to the appropriate method from the NodeVisitor v.

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Field Detail

ANY

public static final Node ANY

The canonical instance of Node_ANY; no-one else need use the constructor.

Method Detail

create

public static Node create(java.lang.String x)

Returns a Node described by the string, primarily for testing purposes. The string represents a URI, a numeric literal, a string literal, a bnode label, or a variable.

• "some text" :: a string literal with that text
• digits :: a literal [OF WHAT TYPE] with that [numeric] value
• _XXX :: a bnode with an AnonId built from _XXX
• ?VVV :: a variable with name VVV
• &PPP :: to be done
• name:stuff :: the URI; name may be expanded using the Standard map

Parameters:

x - the string describing the node

Returns:

a node of the appropriate type with the appropriate label

create

public static 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.

Parameters:

pm - the PrefixMapping for translating pre:X strings

x - the string encoding the node to create

Returns:

a node with the appropriate type and label

createAnon

public static Node createAnon(AnonId id)

make a blank node with the specified label

createLiteral

public static Node createLiteral(com.hp.hpl.jena.graph.impl.LiteralLabel lit)

make a literal node with the specified literal value

createURI

public static Node createURI(java.lang.String uri)

make a URI node with the specified URIref string

createAnon

public static Node createAnon()

make a blank node with a fresh anon id

createVariable

public static Node createVariable(java.lang.String name)

make a variable node with a given name

createLiteral

public static Node createLiteral(java.lang.String lit,
                                 java.lang.String lang,
                                 boolean isXml)

make a literal with specified language and XMLishness. _list_ must *not* be null. This intermediate implementation logs a warning to allow users moving over to Jena2 to correct their code. When they've had the opportunity, arrange to throw an exception, and delete _nullLiteralsGenerateWarnings_ and update the regression tests as directed.

nullLiteralsGenerateWarnings

public static void nullLiteralsGenerateWarnings()

createLiteral

public static Node createLiteral(java.lang.String lex,
                                 java.lang.String lang,
                                 RDFDatatype dtype)
                          throws DatatypeFormatException

Build a typed literal node from its lexical form. The lexical form will be parsed now and the value stored. If the form is not legal this will throw an exception.

Parameters:

lex - the lexical form of the literal

lang - the optional language tag

dtype - the type of the literal, null for old style "plain" literals

Throws:

DatatypeFormatException - if lex is not a legal form of dtype

visitWith

public abstract java.lang.Object visitWith(NodeVisitor v)

Visit a Node and dispatch on it to the appropriate method from the NodeVisitor v.

Parameters:

v - the visitor to apply to the node

Returns:

the value returned by the applied method

isConcrete

public abstract boolean isConcrete()

Answer true iff this node is concrete, ie not variable, ie URI, blank, or literal.

isLiteral

public boolean isLiteral()

is this a literal node - overridden in Node_Literal

isBlank

public boolean isBlank()

is this a blank node - overridden in Node_Blank

isURI

public boolean isURI()

is this a URI node - overridden in Node_URI

isVariable

public boolean isVariable()

is this a variable node - overridden in Node_Variable

getBlankNodeId

public AnonId getBlankNodeId()

get the blank node id if the node is blank, otherwise die horribly

getLiteral

public com.hp.hpl.jena.graph.impl.LiteralLabel getLiteral()

get the literal value of a literal node, otherwise die horribly

getURI

public java.lang.String getURI()

get the URI of this node if it has one, else die horribly

getTriple

public Triple getTriple(GetTriple r)

get the triple associated with this node; if no direct association, use the triple-getter _r_.

getName

public java.lang.String getName()

get a variable nodes name, otherwise die horribly

cache

public static void cache(boolean wantCache)

provided only for testing purposes. _cache(false)_ switches off caching and clears the cache. _cache(true)_ switches caching [back] on. This allows structural equality to be tested.

create

public static 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. We reuse nodes from the recent cache if we can. Otherwise, the maker knows how to construct a new node of the correct class (and the Node constructor will then add it to the cache).

equals

public abstract boolean equals(java.lang.Object o)

Nodes only equal other Nodes that have equal labels.

sameValueAs

public boolean sameValueAs(java.lang.Object o)

Test that two nodes are semantically equivalent. In some cases this may be the sames as equals, in others equals is stricter. For example, two xsd:int literals with the same value but different language tag are semantically equivalent but distinguished by the java equality function in order to support round tripping.

Default implementation is to use equals, subclasses should override this.

hashCode

public int hashCode()

matches

public boolean matches(Node other)

Answer true iff this node accepts the other one as a match. The default is an equality test; it is over-ridden in subclasses to provide the appropriate semantics for literals, ANY, and variables.

Parameters:

other - a node to test for matching

Returns:

true iff this node accepts the other as a match

toString

public java.lang.String toString()

Return the N-Triple representation of this node. hedgehog hack: just use the label's string.