com.hp.hpl.jena.graph
Class Node

java.lang.Object
  extended by com.hp.hpl.jena.graph.Node
Direct Known Subclasses:
Node_Concrete, Node_Fluid

public abstract class Node
extends Object

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.

Author:
Jeremy Carroll and Chris Dollin

Field Summary
static Node ANY
          The canonical instance of Node_ANY; no-one else need use the constructor.
static Node NULL
          The canonical NULL.
 
Method Summary
static void cache(boolean wantCache)
          provided only for testing purposes.
static Node create(com.hp.hpl.jena.graph.Node.NodeMaker maker, Object label)
          We object strongly to null labels: for example, they make .equals flaky.
static Node create(PrefixMapping pm, String x)
          As for create(String), but the PrefixMapping used to translate URI strings is an additional argument.
static Node create(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(String value)
           
static Node createLiteral(String lit, String lang, boolean isXml)
          make a literal with specified language and XMLishness.
static Node createLiteral(String lex, String lang, RDFDatatype dtype)
          Build a typed literal node from its lexical form.
static Node createUncachedLiteral(Object value, String lang, RDFDatatype dtype)
           
static Node createURI(String uri)
          make a URI node with the specified URIref string
static Node createVariable(String name)
          make a variable node with a given name
abstract  boolean equals(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
 String getLocalName()
          get the localname part of this node if it's a URI node, else die horribly
 String getName()
          get a variable nodes name, otherwise die horribly
 String getNameSpace()
          get the namespace part of this node if it's a URI node, else die horribly
 String getURI()
          get the URI of this node if it has one, else die horribly
 int hashCode()
           
 boolean hasURI(String uri)
          answer true iff this node is a URI node with the given URI
 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.
 boolean sameValueAs(Object o)
          Test that two nodes are semantically equivalent.
 String toString()
          Answer a human-readable representation of this Node.
 String toString(boolean quoting)
          Answer a human-readable representation of this Node where literals are quoted according to quoting but URIs are not compressed.
 String toString(PrefixMapping pm)
          Answer a human-readable representation of the Node, quoting literals and compressing URIs.
 String toString(PrefixMapping pm, boolean quoting)
          Answer a human readable representation of this Node, quoting literals if specified, and compressing URIs using the prefix mapping supplied.
abstract  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.


NULL

public static final Node NULL
The canonical NULL. It appears here so that revised definitions [eg as a bnode] that require the cache-and-maker system will work; the NodeMaker constants should be non-null at this point.

Method Detail

create

public static Node create(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.

Parameters:
x - the string describing the node
Returns:
a node of the appropriate type with the appropriate label

create

public static Node create(PrefixMapping pm,
                          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(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(String name)
make a variable node with a given name


createLiteral

public static Node createLiteral(String value)

createLiteral

public static Node createLiteral(String lit,
                                 String lang,
                                 boolean isXml)
make a literal with specified language and XMLishness. _lit_ 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.

Parameters:
isXml - If true then lit is exclusive canonical XML of type rdf:XMLLiteral, and no checking will be invoked.

createLiteral

public static Node createLiteral(String lex,
                                 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

createUncachedLiteral

public static Node createUncachedLiteral(Object value,
                                         String lang,
                                         RDFDatatype dtype)
                                  throws DatatypeFormatException
Throws:
DatatypeFormatException

visitWith

public abstract 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 String getURI()
get the URI of this node if it has one, else die horribly


getNameSpace

public String getNameSpace()
get the namespace part of this node if it's a URI node, else die horribly


getLocalName

public String getLocalName()
get the localname part of this node if it's a URI node, else die horribly


getName

public String getName()
get a variable nodes name, otherwise die horribly


hasURI

public boolean hasURI(String uri)
answer true iff this node is a URI node with the given URI


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,
                          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 we add that node to the cache. create is synchronised to avoid threading problems - a separate thread might zap the cache entry that get is currently looking at.


equals

public abstract boolean equals(Object o)
Nodes only equal other Nodes that have equal labels.

Overrides:
equals in class Object

sameValueAs

public boolean sameValueAs(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()
Overrides:
hashCode in class Object

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 String toString()
Answer a human-readable representation of this Node. It will not compress URIs, nor quote literals (because at the moment too many places use toString() for something machine-oriented).

Overrides:
toString in class Object

toString

public String toString(boolean quoting)
Answer a human-readable representation of this Node where literals are quoted according to quoting but URIs are not compressed.


toString

public String toString(PrefixMapping pm)
Answer a human-readable representation of the Node, quoting literals and compressing URIs.


toString

public String toString(PrefixMapping pm,
                       boolean quoting)
Answer a human readable representation of this Node, quoting literals if specified, and compressing URIs using the prefix mapping supplied.



Copyright © 2000, 2001, 2002, 2003, 2004 Hewlett-Packard Development Company, LP