I can answer this one, as I hit it yesterday.
I learned yesterday that the method validate() can return null, so that
explains your NullPointerException when you call isValid().
ValidityReport validity = modelWine.validate();
if (validity.isValid()) {
-----Original Message-----
From: Léonard PETNGA [mailto:[email protected]]
Sent: Friday, April 26, 2013 3:07 PM
To: [email protected]
Subject: Re: Import and merging of disjoint ontologies in Jena
Hi Ian and all!
Thank you for the link! It has helped me fill in some of the "gaps" in my code.
However, I'm still having trouble with addStatements() method as well as
checkValidity() method (commented) below. I have a NullPointerException error
when calling either or both methods and I don't know where that comes from. Can
you or anyone help me understand what I'm doing wrong in both methods and fix
it?
Error from addStatements()....
Exception in thread "main" java.lang.NullPointerException
[java] at
com.hp.hpl.jena.rdf.model.impl.StatementImpl.<init>(StatementImpl.java:40)
[java] at
com.hp.hpl.jena.rdf.model.impl.ModelCom.createStatement(ModelCom.java:1360)
[java] at
demo.TestWineOntologyOWL.addStatements(TestWineOntologyOWL.java:184)
[java] at demo.TestWineOntologyOWL.main(TestWineOntologyOWL.java:290)
Error from checkValidity()....
==============================================.....Validating the model for
inconsistencies...==============================================
[java]
[java] Exception in thread "main" java.lang.NullPointerException
[java] at
demo.TestWineOntologyOWL.checkValidity(TestWineOntologyOWL.java:100)
[java] at demo.TestWineOntologyOWL.main(TestWineOntologyOWL.java:281)
The complete code....
package demo;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Iterator;
import java.util.List;
import com.hp.hpl.jena.datatypes.xsd.XSDDatatype;
import com.hp.hpl.jena.ontology.DatatypeProperty;
import com.hp.hpl.jena.ontology.Individual;
import com.hp.hpl.jena.ontology.ObjectProperty;
import com.hp.hpl.jena.ontology.OntClass;
import com.hp.hpl.jena.ontology.OntModel;
import com.hp.hpl.jena.ontology.OntModelSpec;
import com.hp.hpl.jena.rdf.model.InfModel;
import com.hp.hpl.jena.rdf.model.Literal;
import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Property;
import com.hp.hpl.jena.rdf.model.RDFNode;
import com.hp.hpl.jena.rdf.model.ResIterator;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.Statement;
import com.hp.hpl.jena.rdf.model.StmtIterator;
import com.hp.hpl.jena.reasoner.Reasoner;
import com.hp.hpl.jena.reasoner.ReasonerRegistry;
import com.hp.hpl.jena.reasoner.ValidityReport;
import com.hp.hpl.jena.reasoner.rulesys.GenericRuleReasoner;
import com.hp.hpl.jena.reasoner.rulesys.Rule;
import com.hp.hpl.jena.shared.DoesNotExistException;
import com.hp.hpl.jena.util.FileManager;
import com.hp.hpl.jena.util.PrintUtil;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.VCARD;
import com.hp.hpl.jena.vocabulary.XSD;
// Create an instance of the OWL reasoner, specialized to the demo schema
// and then apply that to the demo data to obtain an inference model.
public class TestWineOntologyOWL {
//Recall Base URI and namespace declarations for additional entities to be
added to the ontology
static final String baseURI1 = "
http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine";;
static final String ns1 = "
http://www.w3.org/TR/2003/PR-owl-guide-20031209/wine#";;
static final String baseURI2 = "
http://www.w3.org/TR/2003/PR-owl-guide-20031209/food";;
static final String ns2 = "
http://www.w3.org/TR/2003/PR-owl-guide-20031209/food#";;
// additional entities to be added to the loaded ontology
private OntClass DrinkableThing;
private DatatypeProperty hasDateTimeOfMake, hasDuration; // new one to be
added
private Individual wineA, wineB;
//Entities to be extracted from the loaded ontology
private ObjectProperty hasDrink;
private DatatypeProperty hasYearValue ;
// Define the new model
//private Model model;
//String ontURL = "src/demo/ont/wine.owl";
private OntModel modelWine;
String ontURL = "src/demo/ont/wine.owl";
// constructor
public TestWineOntologyOWL() {
modelWine = ModelFactory.createOntologyModel(OntModelSpec.OWL_DL_MEM);
modelWine.read(ontURL);
}
/*
// ============================================================
// Check The validity of the loaded/infered model ...
// ============================================================
public void checkValidity() {
System.out.println("");
System.out.printf("==============================================");
System.out.printf(".....Validating the model for inconsistencies...");
System.out.printf("==============================================");
System.out.println("");
System.out.println("");
ValidityReport validity = modelWine.validate();
if (validity.isValid()) {
System.out.println("Infered model: OK");
} else {
System.out.println("Infered model: Conflicts!!");
for (Iterator i = validity.getReports(); i.hasNext(); ) {
ValidityReport.Report report = (ValidityReport.Report)i.next();
System.out.println(" - " + report);
}
}
}
*/
// ============================================================
// Create and add Classes ...
// ============================================================
public void addClasses() {
System.out.println("");
System.out.printf("=======================================");
System.out.printf(".....Adding new CLASSES to the model...");
System.out.printf("=======================================");
System.out.println("");
// create new class : DrinkableThing
DrinkableThing= modelWine.createClass( ns1 + "DrinkableThing");
// (Re)define RELATIONSHIP among classes ...
modelWine.getOntClass(ns2 + "ConsumableThing").addSubClass ( DrinkableThing
);
}
// ============================================================
// Create and add properties ...
// ============================================================
public void addProperties() {
System.out.println("");
System.out.printf("==========================================");
System.out.printf(".....Extracting/Adding new PROPERTIES to the model..."
);
System.out.printf("==========================================");
System.out.println("");
// Extract existing properties in the loaded ontology as variables....
hasYearValue = modelWine.getDatatypeProperty(ns2 + "yearValue");
hasDrink = modelWine.getObjectProperty(ns2 + "hasDrink");
// add DatatypeProperty "hasDateTimeOfMake"
hasDateTimeOfMake = modelWine.createDatatypeProperty(ns2 +
"hasDateTimeOfMake");
hasDateTimeOfMake.addDomain(modelWine.getOntClass(ns2 + "ConsumableThing"
));
hasDateTimeOfMake.addRange(XSD.dateTime);
// add DatatypeProperty "hasDuration"
hasDuration = modelWine.createDatatypeProperty(ns2 + "hasDuration");
hasDuration.addDomain(modelWine.getOntClass(ns2 + "ConsumableThing"));
hasDuration.addRange(XSD.duration);
}
// ============================================================
// Create and add individuals ...
// ============================================================
public void addIndividuals() {
System.out.println("");
System.out.printf("===========================================");
System.out.printf(".....Extracting/Adding new INDIVIDUALS to the model...");
System.out.printf("===========================================");
System.out.println("");
// Create and Add an individual as instance of an existing class
(ConsumableThing) in the loaded ontology : wineA ...
wineA = modelWine.getOntClass(ns2 + "ConsumableThing"
).createIndividual(ns2 + "wineA");
// Create and Add an individual as instance of a newly created class
: wineB ...
wineB = DrinkableThing.createIndividual(ns2 + "wineB");
}
// ============================================================
// Create and add Statements ...
// ============================================================
public void addStatements() {
// Statement with property from the loaded ontology (yearValue)
Literal yearA = modelWine.createTypedLiteral("2003", XSDDatatype.
XSDpositiveInteger);
Statement yearMakeWA = modelWine.createStatement(wineA, modelWine
.getDatatypeProperty(ns2 + "yearValue"), yearA );
modelWine.add ( yearMakeWA );
// Statement with property (yearValue) and Individual from the loaded
ontology ()
Statement yearMake = modelWine.createStatement(modelWine.getIndividual(
ns1 + "ChateauMargaux"), modelWine.getDatatypeProperty(ns2 + "yearValue"),
yearA );
modelWine.add ( yearMake );
// Statement with an added property (hasDateTimeOfMake) and literal
(timeWB)
Literal timeWB = modelWine.createTypedLiteral("2003-02-28T09:00:00Z",
XSDDatatype.XSDdateTime );
Statement timeMakeWB = modelWine.createStatement(wineB, hasDateTimeOfMake,
timeWB );
modelWine.add ( timeMakeWB );
// Statement with an added property (hasDuration) and literal
(duration10y)
Literal duration10y = modelWine.createTypedLiteral("P10YT5H10S",
XSDDatatype.XSDduration );
Statement durationWB = modelWine.createStatement(wineB, hasDuration,
duration10y);
modelWine.add ( durationWB );
}
// ============================================================
// Retrieve and print VCARD ....
// ============================================================
public void printVCARDS( String sTitle ) {
System.out.printf("List of statements: %s\n", sTitle );
System.out.printf(
"=============================================================\n");
// select all the resources with a VCARD.FN property
ResIterator iter = modelWine.listResourcesWithProperty(VCARD.FN);
if (iter.hasNext()) {
System.out.println("The database contains vcards for:");
while (iter.hasNext()) {
System.out.println(" " + iter.nextResource()
.getRequiredProperty(VCARD.FN)
.getString() );
}
} else {
System.out.println("No vcards were found in the database");
}
}
// ============================================================
// Retrieve and print the RDF statements ....
// ============================================================
public void printStatements( String sTitle ) {
int statementNo = 1;
System.out.printf("List of statements: %s\n", sTitle );
System.out.printf(
"=============================================================\n");
StmtIterator iter = modelWine.listStatements();
while (iter.hasNext()) {
Statement stmt = iter.next(); // get next statement
Resource subject = stmt.getSubject(); // get the subject
Property predicate = stmt.getPredicate(); // get the predicate
RDFNode object = stmt.getObject(); // get the object
// Objects can be either Resources or Literals ....
System.out.printf(" Statement[%4d]\n", statementNo );
System.out.printf(" Subject : %s \n", subject.toString());
System.out.printf(" Predicate: %s \n", predicate.toString());
if (object instanceof Resource) {
System.out.printf(" Object : %s \n", object.toString());
}
if (object instanceof Literal) {
System.out.printf(" Object : \"%s\" \n", object.toString());
}
statementNo = statementNo + 1;
}
System.out.println(
"=============================================================");
}
public static void main(String[] args) {
System.out.println("Step 1: Load the Wine Ontology ....
");
System.out.println(
"===================================================");
TestWineOntologyOWL wine = new TestWineOntologyOWL();
System.out.println("");
System.out.printf("Step 2: Check the validity and Print size of the Wine
Ontology ...\n");
System.out.println(
"==================================================================");
System.out.println("");
// wine.checkValidity();
System.out.println("");
System.out.println("Initial Wine ontology model size = " + wine.
modelWine.size());
System.out.println("");
wine.addClasses();
wine.addProperties();
wine.addIndividuals();
wine.addStatements();
System.out.println("");
System.out.println("Wine ontology model size after extension = " +
wine.modelWine.size());
System.out.println("");
System.out.println("");
System.out.printf("Step 3: Print details of the Wine Ontology ...\n");
System.out.println("===============================================");
System.out.println("");
wine.modelWine.write(System.out, "RDF/XML" );
System.out.println("");
System.out.printf("Step 4: Print statements in the Wine Ontology ...\n");
System.out.println("===============================================");
System.out.println("");
wine.printStatements( "Wine Ontology" );
System.out.println("");
System.out.println("===============================================");
System.out.printf("Step 5: Print VCARD in the Wine Ontology ...\n");
System.out.println("===============================================");
System.out.println("");
wine.printVCARDS( "VCARDs in Wine Ontology" );
System.out.println("");
System.out.println("===============================================");
}
}
2013/4/25 Ian Dickinson <[email protected]>
> Hi Léonard,
>
> On 25/04/13 02:17, Léonard PETNGA wrote:
>
>> Hi Ian,
>> From your answer above it looks like Jena does allow to create
>> individuals, delete/add classes, statements and properties to the
>> loaded owl ontology model
>>
> Yes. Have you read:
>
> http://jena.apache.org/**documentation/ontology/index.**html<http://je
> na.apache.org/documentation/ontology/index.html>
>
>
> directly from the java file. I guess the question is how? I would
> like to
>> focus our exchange back to a real case to illustrate part of my
>> problem using the excerpt below. I've loaded the wine ontology (.owl) in an
>> empty
>> model and would like to write code to enrich/modify that ontology
>> (see the various methods listed). Do you or anyone have example code
>> to help fill in the gaps?
>>
>
> I'm sorry, but how can we fill in a specification like this:
>
>
> // ==============================**==============================
>> // Create and add individuals ...
>> // ==============================**==============================
>> public void addIndividuals() {
>> //????
>> }
>>
>
> That provides no information at all about what the code should do.
> That spec says "write a method that takes no arguments, returns no
> value, and does something". I agree that focusing on a real case would
> be helpful, but this isn't that.
>
> Ian
>
>
