get OWL restrictions on classes using Jena

Using the pizza ontology, I want to be able to look up all the toppings for American pizza. If I open the ontology in Protégé, I can see that American pizza has the following restrictions:

hasTopping some MozerellaTopping
hasTopping some TomatoToppin开发者_如何转开发g

How can I get the same information programatically through Jena?

Here's my solution. I've just printed out the strings you ask for, but hopefully you can see from this how to use the Jena OntAPI to traverse an ontology graph and pick out the things you're interested in.

package examples;
import java.util.Iterator;
import com.hp.hpl.jena.ontology.*;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Resource;

public class PizzaExample
{
    /***********************************/
    /* Constants                       */
    /***********************************/
    public static String BASE = "http://www.co-ode.org/ontologies/pizza/pizza.owl";
    public static String NS = BASE + "#";

    /***********************************/
    /* External signature methods      */
    /***********************************/

    public static void main( String[] args ) {
        new PizzaExample().run();
    }

    public void run() {
        OntModel m = getPizzaOntology();
        OntClass american = m.getOntClass( NS + "American" );

        for (Iterator<OntClass> supers = american.listSuperClasses(); supers.hasNext(); ) {
            displayType( supers.next() );
        }
    }

    /***********************************/
    /* Internal implementation methods */
    /***********************************/

    protected OntModel getPizzaOntology() {
        OntModel m = ModelFactory.createOntologyModel( OntModelSpec.OWL_MEM );
        m.read( BASE );
        return m;
    }

    protected void displayType( OntClass sup ) {
        if (sup.isRestriction()) {
            displayRestriction( sup.asRestriction() );
        }
    }

    protected void displayRestriction( Restriction sup ) {
        if (sup.isAllValuesFromRestriction()) {
            displayRestriction( "all", sup.getOnProperty(), sup.asAllValuesFromRestriction().getAllValuesFrom() );
        }
        else if (sup.isSomeValuesFromRestriction()) {
            displayRestriction( "some", sup.getOnProperty(), sup.asSomeValuesFromRestriction().getSomeValuesFrom() );
        }
    }

    protected void displayRestriction( String qualifier, OntProperty onP, Resource constraint ) {
        String out = String.format( "%s %s %s",
                                    qualifier, renderURI( onP ), renderConstraint( constraint ) );
        System.out.println( "american pizza: " + out );
    }

    protected Object renderConstraint( Resource constraint ) {
        if (constraint.canAs( UnionClass.class )) {
            UnionClass uc = constraint.as( UnionClass.class );
            // this would be so much easier in ruby ...
            String r = "union{ ";
            for (Iterator<? extends OntClass> i = uc.listOperands(); i.hasNext(); ) {
                r = r + " " + renderURI( i.next() );
            }
            return r + "}";
        }
        else {
            return renderURI( constraint );
        }
    }

    protected Object renderURI( Resource onP ) {
        String qName = onP.getModel().qnameFor( onP.getURI() );
        return qName == null ? onP.getLocalName() : qName;
    }
}

Which produces the following output:

american pizza: some pizza:hasTopping pizza:MozzarellaTopping
american pizza: some pizza:hasTopping pizza:PeperoniSausageTopping
american pizza: some pizza:hasTopping pizza:TomatoTopping
american pizza: all pizza:hasTopping union{  pizza:MozzarellaTopping pizza:TomatoTopping pizza:PeperoniSausageTopping}

For Apache Jena 3.x.x (and also for 2.x) there is one potential problem related to the org.apache.jena.ontology.OntModel and pizza.owl: Jena supports only OWL1, but pizza is OWL2 ontology.

Ans, although, for the example above it doesn't matter ('Existential Quantification' restrictions looks identically both for OWL1 and OWL2, and Jena API can process it), in general case you can't use org.apache.jena.ontology.OntModel for processing ontology just as easily.

As an option there is an alternative named com.github.owlcs.ontapi.jena.model.OntModel from ONT-API. This model is based on the same principles as a Jena OntModel, but it is strongly for OWL2 (and, also, it is not InfModel - at time of writing).

Consider an example of usage (object-some-values-from restrictions for a class):

    String web = "https://raw.githubusercontent.com/owlcs/ont-api/master/src/test/resources/ontapi/pizza.ttl";
    // create an OWL2 RDF-view (Jena Model):
    OntModel m = com.github.owlcs.ontapi.jena.OntModelFactory.createModel();
    // load pizza ontology from web
    m.read(web, "ttl");
    // find class and property
    OntClass clazz = m.getOntClass(m.expandPrefix(":American"));
    OntObjectProperty prop = m.getObjectProperty(m.expandPrefix(":hasTopping"));
    // list and print all some values from restrictions with desired property
    clazz.superClasses()
            .filter(c -> c.canAs(OntClass.ObjectSomeValuesFrom.class))
            .map(c -> c.as(OntClass.ObjectSomeValuesFrom.class))
            .filter(c -> prop.equals(c.getProperty()))
            .map(x -> x.getValue())
            .forEach(System.out::println);

The output:

http://www.co-ode.org/ontologies/pizza/pizza.owl#PeperoniSausageTopping(OntClass)
http://www.co-ode.org/ontologies/pizza/pizza.owl#TomatoTopping(OntClass)
http://www.co-ode.org/ontologies/pizza/pizza.owl#MozzarellaTopping(OntClass)