org.mindswap.pellet.jena.graph.loader

Class DefaultGraphLoader

java.lang.Object

org.mindswap.pellet.jena.graph.loader.DefaultGraphLoader

All Implemented Interfaces:

GraphLoader

public class DefaultGraphLoader
extends Object
implements GraphLoader

Title:

Description:

Copyright: Copyright (c) 2008

Company: Clark & Parsia, LLC.

Author:

Evren Sirin

Field Summary

Fields

Modifier and Type	Field and Description
protected Set<com.hp.hpl.jena.graph.Node>	anonDatatypes
protected com.hp.hpl.jena.graph.Graph	graph
protected KnowledgeBase	kb
protected Map<com.hp.hpl.jena.graph.Node,aterm.ATermList>	lists
static Logger	log
protected ProgressMonitor	monitor
protected Map<com.hp.hpl.jena.graph.Node,BuiltinTerm>	naryDisjoints
static QNameProvider	qnames
protected static com.hp.hpl.jena.graph.Node[]	TBOX_PREDICATES
protected static com.hp.hpl.jena.graph.Node[]	TBOX_TYPES
protected Map<com.hp.hpl.jena.graph.Node,aterm.ATermAppl>	terms

Constructor Summary

Constructors

Constructor and Description
DefaultGraphLoader()

Method Summary

Methods

Modifier and Type	Method and Description
protected void	addSimpleProperty(aterm.ATermAppl p, SimpleProperty why)
protected void	addUnsupportedFeature(String msg)
void	clear() Clear all internal caches (essentially used for mapping bnodes to ATerm structures)
protected aterm.ATermList	createList(org.mindswap.pellet.jena.graph.loader.DefaultGraphLoader.RDFListIterator i)
protected aterm.ATermList	createList(com.hp.hpl.jena.graph.Node node)
protected aterm.ATermAppl	createRestriction(com.hp.hpl.jena.graph.Node node)
protected aterm.ATermAppl	createRestriction(com.hp.hpl.jena.graph.Node restrictionType, com.hp.hpl.jena.graph.Node p, com.hp.hpl.jena.graph.Node filler, com.hp.hpl.jena.graph.Node qualification, Bool isObjectRestriction)
protected boolean	defineClass(aterm.ATermAppl c)
protected boolean	defineDatatype(aterm.ATermAppl dt)
protected boolean	defineDatatypeProperty(aterm.ATermAppl c)
protected boolean	defineIndividual(aterm.ATermAppl c)
protected boolean	defineObjectProperty(aterm.ATermAppl c)
protected boolean	defineProperty(aterm.ATermAppl c)
protected com.hp.hpl.jena.graph.Triple	getExpression(com.hp.hpl.jena.graph.Node node)
protected com.hp.hpl.jena.graph.Node	getFirst(com.hp.hpl.jena.graph.Node list)
com.hp.hpl.jena.graph.Graph	getGraph() Get the Jena graph used in the loader.
protected com.hp.hpl.jena.graph.Node	getRest(com.hp.hpl.jena.graph.Node list)
Set<String>	getUnpportedFeatures() Returns the unsupported axioms ignored by the loader.
boolean	isLoadABox() Returns if the loader will load the Abox triples.
boolean	isPreprocessTypeTriples() Returns if the loader will preprocess rdf:type triples.
protected boolean	isRestriction(com.hp.hpl.jena.graph.Node node)
void	load(Iterable<com.hp.hpl.jena.graph.Graph> graphs) Load the axioms from the Jena graphs to the given KB.
aterm.ATermAppl	node2term(com.hp.hpl.jena.graph.Node node) Translate the given graph node into an ATerm object.
void	preprocess() Do the preprocessing steps necessary to cache any information that will be used for loading.
protected void	processTriple(com.hp.hpl.jena.graph.Triple triple) Process a single triple that corresponds to an axiom (or a fact).
protected void	processTriples() Process all the triples in the raw graph.
protected void	processTriples(com.hp.hpl.jena.graph.Node predicate) Process triples with the given predicate.
protected void	processType(com.hp.hpl.jena.graph.Triple triple) Process a single rdf:type triple.
protected void	processTypes() Process all triples with rdf:type predicate.
protected void	processTypes(com.hp.hpl.jena.graph.Node type) Process triples with rdf:type predicate and given object.
protected void	processUntypedResources()
void	setGraph(com.hp.hpl.jena.graph.Graph graph) Set the graph that will be used during loading.
void	setKB(KnowledgeBase kb)
void	setLoadABox(boolean loadABox) Sets the flag that tells the loader to skip ABox (instance) statements.
void	setPreprocessTypeTriples(boolean preprocessTypeTriples) This option forces the loader to process type triples before processing other triples.
void	setProgressMonitor(ProgressMonitor monitor) Set the progress monitor that will show the load progress.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

log

public static final Logger log

TBOX_TYPES

protected static final com.hp.hpl.jena.graph.Node[] TBOX_TYPES

TBOX_PREDICATES

protected static final com.hp.hpl.jena.graph.Node[] TBOX_PREDICATES

qnames

public static QNameProvider qnames

kb

protected KnowledgeBase kb

graph

protected com.hp.hpl.jena.graph.Graph graph

terms

protected Map<com.hp.hpl.jena.graph.Node,aterm.ATermAppl> terms

lists

protected Map<com.hp.hpl.jena.graph.Node,aterm.ATermList> lists

anonDatatypes

protected Set<com.hp.hpl.jena.graph.Node> anonDatatypes

naryDisjoints

protected Map<com.hp.hpl.jena.graph.Node,BuiltinTerm> naryDisjoints

monitor

protected ProgressMonitor monitor

Constructor Detail

DefaultGraphLoader

public DefaultGraphLoader()

Method Detail

setProgressMonitor

public void setProgressMonitor(ProgressMonitor monitor)

Set the progress monitor that will show the load progress.

Specified by:

setProgressMonitor in interface GraphLoader

setGraph

public void setGraph(com.hp.hpl.jena.graph.Graph graph)

Set the graph that will be used during loading.

Specified by:

setGraph in interface GraphLoader

getGraph

public com.hp.hpl.jena.graph.Graph getGraph()

Get the Jena graph used in the loader.

Specified by:

getGraph in interface GraphLoader

Returns:

getUnpportedFeatures

public Set<String> getUnpportedFeatures()

Returns the unsupported axioms ignored by the loader.

Specified by:

getUnpportedFeatures in interface GraphLoader

Returns:

addSimpleProperty

protected void addSimpleProperty(aterm.ATermAppl p,
                     SimpleProperty why)

addUnsupportedFeature

protected void addUnsupportedFeature(String msg)

clear

public void clear()

Clear all internal caches (essentially used for mapping bnodes to ATerm structures)

Specified by:

clear in interface GraphLoader

getFirst

protected com.hp.hpl.jena.graph.Node getFirst(com.hp.hpl.jena.graph.Node list)

getRest

protected com.hp.hpl.jena.graph.Node getRest(com.hp.hpl.jena.graph.Node list)

createList

protected aterm.ATermList createList(com.hp.hpl.jena.graph.Node node)

createList

protected aterm.ATermList createList(org.mindswap.pellet.jena.graph.loader.DefaultGraphLoader.RDFListIterator i)

isRestriction

protected boolean isRestriction(com.hp.hpl.jena.graph.Node node)

createRestriction

protected aterm.ATermAppl createRestriction(com.hp.hpl.jena.graph.Node node)
                                     throws UnsupportedFeatureException

Throws:

UnsupportedFeatureException

createRestriction

protected aterm.ATermAppl createRestriction(com.hp.hpl.jena.graph.Node restrictionType,
                                com.hp.hpl.jena.graph.Node p,
                                com.hp.hpl.jena.graph.Node filler,
                                com.hp.hpl.jena.graph.Node qualification,
                                Bool isObjectRestriction)
                                     throws UnsupportedFeatureException

Throws:

UnsupportedFeatureException

node2term

public aterm.ATermAppl node2term(com.hp.hpl.jena.graph.Node node)

Translate the given graph node into an ATerm object.

Specified by:

node2term in interface GraphLoader

Returns:

getExpression

protected com.hp.hpl.jena.graph.Triple getExpression(com.hp.hpl.jena.graph.Node node)

defineClass

protected boolean defineClass(aterm.ATermAppl c)

defineDatatype

protected boolean defineDatatype(aterm.ATermAppl dt)

defineObjectProperty

protected boolean defineObjectProperty(aterm.ATermAppl c)

defineDatatypeProperty

protected boolean defineDatatypeProperty(aterm.ATermAppl c)

defineProperty

protected boolean defineProperty(aterm.ATermAppl c)

defineIndividual

protected boolean defineIndividual(aterm.ATermAppl c)

processTypes

protected void processTypes()

Process all triples with rdf:type predicate. If PelletOptions#PREPROCESS_TYPE_TRIPLES option is true this function is a noop.

processTypes

protected void processTypes(com.hp.hpl.jena.graph.Node type)

Process triples with rdf:type predicate and given object. Type can be Node.ANY to indicate all type triples should be processed.

Parameters:

type - the object of rdf:type triples to be processed

processType

protected void processType(com.hp.hpl.jena.graph.Triple triple)

Process a single rdf:type triple. Type triples that are part of the OWL syntax, e.g. _:x rdf:type owl:Restriction will not be processed since they are handled by the node2term(Node) function.

Parameters:

triple - Type triple that will be processed

processTriples

protected void processTriples()

Process all the triples in the raw graph. If PelletOptions#PREPROCESS_TYPE_TRIPLES option is true all rdf:type will be ignored since they have already been processed with processTypes() function.

processTriples

protected void processTriples(com.hp.hpl.jena.graph.Node predicate)

Process triples with the given predicate. Predicate can be Node.ANY to indicate all triples should be processed.

Parameters:

predicate - Predicate of the triples that will be processed

processTriple

protected void processTriple(com.hp.hpl.jena.graph.Triple triple)

Process a single triple that corresponds to an axiom (or a fact). This means triples that are part of OWL syntax, e.g. a triple with owl:onProperty predicate, will not be processed since they are handled by the node2term(Node) function. Also, if PelletOptions#PREPROCESS_TYPE_TRIPLES option is true any triple with rdf:type predicate will be ignored.

Parameters:

triple - Triple to be processed.

processUntypedResources

protected void processUntypedResources()

setKB

public void setKB(KnowledgeBase kb)

Specified by:

setKB in interface GraphLoader

load

public void load(Iterable<com.hp.hpl.jena.graph.Graph> graphs)
          throws UnsupportedFeatureException

Load the axioms from the Jena graphs to the given KB.

Specified by:

load in interface GraphLoader

Throws:

UnsupportedFeatureException

preprocess

public void preprocess()

Do the preprocessing steps necessary to cache any information that will be used for loading.

Specified by:

preprocess in interface GraphLoader

isLoadABox

public boolean isLoadABox()

Description copied from interface: GraphLoader

Returns if the loader will load the Abox triples.

Specified by:

isLoadABox in interface GraphLoader

Returns:

boolean value indicating if ABox triples will be loaded

See Also:

GraphLoader.setLoadABox(boolean)

setLoadABox

public void setLoadABox(boolean loadABox)

Description copied from interface: GraphLoader

Sets the flag that tells the loader to skip ABox (instance) statements. Only TBox (class) and RBox (property) axioms will be loaded. Improves loading performance even if there are no ABox statements because lets the loader to ignore annotations.

Specified by:

setLoadABox in interface GraphLoader

isPreprocessTypeTriples

public boolean isPreprocessTypeTriples()

Description copied from interface: GraphLoader

Returns if the loader will preprocess rdf:type triples.

Specified by:

isPreprocessTypeTriples in interface GraphLoader

Returns:

boolean value indicating if rdf:type triples will be preprocessed

See Also:

GraphLoader.setPreprocessTypeTriples(boolean)

setPreprocessTypeTriples

public void setPreprocessTypeTriples(boolean preprocessTypeTriples)

Description copied from interface: GraphLoader

This option forces the loader to process type triples before processing other triples. Not preprocessing the type triples improves loading time 5% to 10% but might cause problems too. For example, without preprocessing the type triples a triple (s p "o") might be loaded as a datatype assertion (thinking s is an individual and p is a datatype property) whereas (s rdf:type owl:Class) and (p rdf:type owl:AnnotiationProperty) triples have not yet been processed. These problems depend on the order triples are processed and highly unpredictable. Loading the schema first with preprocessing and loading the instance data without preprocessing would be a viable option if schema and instance data are in separate files.

Specified by:

setPreprocessTypeTriples in interface GraphLoader