public boolean assertDataPropertyInstance(String ind, String prop, int value) { OWLDataProperty dataProp = OWLFactory.getOWLDataProperty( IRI.create(topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + prop)); OWLDataPropertyAssertionAxiom tmpAx = OWLFactory.getOWLDataPropertyAssertionAxiom( dataProp, OWLFactory.getOWLNamedIndividual( IRI.create(topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + ind)), OWLFactory.getOWLLiteral(value)); manager.addAxiom(topIxOnt, tmpAx); return true; }
//////////////////////////////// // INDIVIDUAL ASSERTION METHODS// //////////////////////////////// public boolean assertSiteIndividual(String siteNameHash, String siteNameAnnotation) { OWLClassExpression tmpCE = OWLFactory.getOWLClass(":Site", topIxPrefixManager); OWLIndividual tmpInd = OWLFactory.getOWLNamedIndividual(':' + siteNameHash, topIxPrefixManager); manager.addAxiom(topIxOnt, OWLFactory.getOWLClassAssertionAxiom(tmpCE, tmpInd)); manager.addAxiom( topIxOnt, OWLFactory.getOWLAnnotationAssertionAxiom( OWLFactory.getOWLAnnotationProperty( IRI.create( topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + "individualName")), IRI.create(topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + siteNameHash), OWLFactory.getOWLLiteral(siteNameAnnotation))); return true; }
public void classifyOntology(OWLOntology ontology, OWLReasonerFactory factory) { ToStringRenderer.getInstance().setRenderer(new ManchesterOWLSyntaxOWLObjectRendererImpl()); OWLReasoner reasoner = factory.createNonBufferingReasoner(ontology); // reasoner.precomputeInferences(InferenceType.values()); long time = System.currentTimeMillis(); boolean isConsistent = reasoner.isConsistent(); int numOfUnsatClasses = reasoner.getUnsatisfiableClasses().getEntitiesMinusBottom().size(); time = System.currentTimeMillis() - time; DLExpressivityChecker checker = new DLExpressivityChecker(Collections.singleton(ontology)); String e = checker.getDescriptionLogicName(); String name = ontology.getOntologyID().getOntologyIRI().getFragment(); logger.info( "ontology: " + name + ", reasoner: " + factory.getReasonerName() + ", expressivity: " + e + ", consistent: " + isConsistent + ", unsat classes: " + numOfUnsatClasses + ", time: " + time); }
private OWLOntology findOntology(List<OWLOntology> loadedOntologies, IRI documentIRI) { for (OWLOntology o : loadedOntologies) { if (documentIRI.equals(o.getOntologyID().getOntologyIRI())) { return o; } } return null; }
public boolean assertHouseIndividual(String houseEntryHash, String houseEntryAnnotation) { OWLClassExpression tempClassExpression = OWLFactory.getOWLClass(":House", topIxPrefixManager); OWLIndividual tempIndividual = OWLFactory.getOWLNamedIndividual(':' + houseEntryHash, topIxPrefixManager); manager.addAxiom( topIxOnt, OWLFactory.getOWLClassAssertionAxiom(tempClassExpression, tempIndividual)); manager.addAxiom( topIxOnt, OWLFactory.getOWLAnnotationAssertionAxiom( OWLFactory.getOWLAnnotationProperty( IRI.create( topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + "individualName")), IRI.create(topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + houseEntryHash), OWLFactory.getOWLLiteral(houseEntryAnnotation))); return true; }
public void mergeOntologies() { List<OWLOntologyChange> changes = new ArrayList<OWLOntologyChange>(); for (OWLOntology ont : ontologies) { if (!ont.equals(targetOntology)) { // move the axioms for (OWLAxiom ax : ont.getAxioms()) { changes.add(new AddAxiom(targetOntology, ax)); } // move ontology annotations for (OWLAnnotation annot : ont.getAnnotations()) { changes.add(new AddOntologyAnnotation(targetOntology, annot)); } if (!targetOntology.getOntologyID().isAnonymous()) { // move ontology imports for (OWLImportsDeclaration decl : ont.getImportsDeclarations()) { if (ontologies.contains(ont.getOWLOntologyManager().getImportedOntology(decl))) { continue; } Optional<IRI> defaultDocumentIRI = targetOntology.getOntologyID().getDefaultDocumentIRI(); if (defaultDocumentIRI.isPresent() && !decl.getIRI().equals(defaultDocumentIRI.get())) { changes.add(new AddImport(targetOntology, decl)); } else { logger.warn( "Merge: ignoring import declaration for ontology " + targetOntology.getOntologyID() + " (would result in target ontology importing itself)."); } } } } } try { owlOntologyManager.applyChanges(changes); } catch (OWLOntologyChangeException e) { ErrorLogPanel.showErrorDialog(e); } }
// asserts a hasHouse property instance between a house and its corresponding // site public boolean assertHasHousePropertyInstance(String houseEntryHash, String siteNameHash) { OWLObjectProperty objProp = OWLFactory.getOWLObjectProperty( IRI.create(topIxOnt.getOntologyID().getOntologyIRI() + "#hasHouse")); OWLIndividual houseIndividual = OWLFactory.getOWLNamedIndividual(':' + houseEntryHash, topIxPrefixManager); OWLIndividual siteIndividual = OWLFactory.getOWLNamedIndividual(':' + siteNameHash, topIxPrefixManager); manager.addAxiom( topIxOnt, OWLFactory.getOWLObjectPropertyAssertionAxiom(objProp, siteIndividual, houseIndividual)); return true; }
public boolean assertHasRoomPropertyInstance( String houseIndividualHash, String roomIndividualHash) { OWLObjectProperty tempOWLbjectProperty = OWLFactory.getOWLObjectProperty( IRI.create(topIxOnt.getOntologyID().getOntologyIRI() + "#hasRoom")); OWLIndividual houseIndividual = OWLFactory.getOWLNamedIndividual(':' + houseIndividualHash, topIxPrefixManager); OWLIndividual roomIndividual = OWLFactory.getOWLNamedIndividual(':' + roomIndividualHash, topIxPrefixManager); manager.addAxiom( topIxOnt, OWLFactory.getOWLObjectPropertyAssertionAxiom( tempOWLbjectProperty, houseIndividual, roomIndividual)); return true; }
public boolean assertRoomIndividual( String roomName, String roomIndividualHash, String roomIndividualAnnotation) { OWLClassExpression tempClassExpression = OWLFactory.getOWLClass( IRI.create( roomToIRI.get( roomName))); // retrieves the Room Class IRI fron the roomToIRI map, using // roomID as a key. OWLIndividual tempIndividual = OWLFactory.getOWLNamedIndividual(':' + roomIndividualHash, topIxPrefixManager); manager.addAxiom( topIxOnt, OWLFactory.getOWLClassAssertionAxiom(tempClassExpression, tempIndividual)); manager.addAxiom( topIxOnt, OWLFactory.getOWLAnnotationAssertionAxiom( OWLFactory.getOWLAnnotationProperty( IRI.create( topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + "individualName")), IRI.create( topIxOnt.getOntologyID().getOntologyIRI().toString() + '#' + roomIndividualHash), OWLFactory.getOWLLiteral(String.format(roomIndividualAnnotation)))); return true; }
public void loadOntology() { try { /* * --apaitoymena vimata gia th dhmioyrgia mapped ontologias: * 1.dhmioyrgoyme ena toBeMappedIRI me skopo toy thn antistoixish me * to local File. 2.dhmioyrgoyme ena File me th dieythynsh ths * ontologias sto topiko apothikeytiko meso. 3.dhmioyrgoyme enan * SimpleIRIMapper kai ton prosthetoyme mesw toy manager. o * SimpleIRIMapper syndeei to toBeMappedIRI poy dwsame arxika, me * thn fysikh topothesia ths ontologias sto topiko apothikeytiko * meso. 4.dhmioyrgoyme ena ontologyIRI me akrivws thn idia arxiki * timh me to toBeMappedIRI to opoio tha einai to IRI ths ontologias * mas 5.dhmioyrgoyme thn ontologia mas xrhsimopoiwntas to * manager.loadOntology(ontologyIRI); */ String sep = File.separator; manager = OWLManager.createOWLOntologyManager(); toBeMappedIRI = IRI.create( "http://www.semanticweb.org/ontologies/ptyxiaki_v0.6/2011/5/Ontology1308067064597.owl"); // ontFile = new File("../src/ontologyresources/ptyxiaki_v0.8.owl"); ontFile = new File("src/ontologyresources/ptyxiaki_v0.8.owl"); // in case of alternative location on load time when the application is jar'ed! if (!ontFile.canRead()) { ontFile = new File("ontologyresources/ptyxiaki_v0.8.owl"); } manager.addIRIMapper(new SimpleIRIMapper(toBeMappedIRI, IRI.create(ontFile))); ontologyIRI = IRI.create( "http://www.semanticweb.org/ontologies/ptyxiaki_v0.6/2011/5/Ontology1308067064597.owl"); topIxOnt = manager.loadOntology(ontologyIRI); OWLFactory = manager.getOWLDataFactory(); topIxFormat = manager.getOntologyFormat(topIxOnt); topIxPrefixManager = new DefaultPrefixManager(topIxOnt.getOntologyID().getOntologyIRI().toString() + '#'); System.out.println("loaded ontology: " + this.topIxOnt); System.out.println("from: " + this.manager.getOntologyDocumentIRI(this.topIxOnt)); } catch (OWLException oex) { logger.info(oex.getMessage()); } }
public static void main(String[] args) { try { // Create our ontology manager in the usual way. OWLOntologyManager manager = OWLManager.createOWLOntologyManager(); // Load a copy of the people+pets ontology. We'll load the ontology from the web (it's // acutally located // in the TONES ontology repository). IRI docIRI = IRI.create(DOCUMENT_IRI); // We load the ontology from a document - our IRI points to it directly OWLOntology ont = manager.loadOntologyFromOntologyDocument(docIRI); System.out.println("Loaded " + ont.getOntologyID()); // We need to create an instance of OWLReasoner. An OWLReasoner provides the basic // query functionality that we need, for example the ability obtain the subclasses // of a class etc. To do this we use a reasoner factory. // Create a reasoner factory. In this case, we will use HermiT, but we could also // use FaCT++ (http://code.google.com/p/factplusplus/) or // Pellet(http://clarkparsia.com/pellet) // Note that (as of 03 Feb 2010) FaCT++ and Pellet OWL API 3.0.0 compatible libraries are // expected to be available in the near future). // For now, we'll use HermiT // HermiT can be downloaded from http://hermit-reasoner.com // Make sure you get the HermiT library and add it to your class path. You can then // instantiate the HermiT reasoner factory: // Comment out the first line below and uncomment the second line below to instantiate // the HermiT reasoner factory. You'll also need to import the // org.semanticweb.HermiT.Reasoner // package. OWLReasonerFactory reasonerFactory = null; // OWLReasonerFactory reasonerFactory = new Reasoner.ReasonerFactory(); // We'll now create an instance of an OWLReasoner (the implementation being provided by HermiT // as // we're using the HermiT reasoner factory). The are two categories of reasoner, Buffering // and // NonBuffering. In our case, we'll create the buffering reasoner, which is the default kind // of reasoner. // We'll also attach a progress monitor to the reasoner. To do this we set up a configuration // that // knows about a progress monitor. // Create a console progress monitor. This will print the reasoner progress out to the // console. ConsoleProgressMonitor progressMonitor = new ConsoleProgressMonitor(); // Specify the progress monitor via a configuration. We could also specify other setup // parameters in // the configuration, and different reasoners may accept their own defined parameters this // way. OWLReasonerConfiguration config = new SimpleConfiguration(progressMonitor); // Create a reasoner that will reason over our ontology and its imports closure. Pass in the // configuration. OWLReasoner reasoner = reasonerFactory.createReasoner(ont, config); // Ask the reasoner to do all the necessary work now reasoner.precomputeInferences(); // We can determine if the ontology is actually consistent (in this case, it should be). boolean consistent = reasoner.isConsistent(); System.out.println("Consistent: " + consistent); System.out.println("\n"); // We can easily get a list of unsatisfiable classes. (A class is unsatisfiable if it // can't possibly have any instances). Note that the getUnsatisfiableClasses method // is really just a convenience method for obtaining the classes that are equivalent // to owl:Nothing. In our case there should be just one unsatisfiable class - "mad_cow" // We ask the reasoner for the unsatisfiable classes, which returns the bottom node // in the class hierarchy (an unsatisfiable class is a subclass of every class). Node<OWLClass> bottomNode = reasoner.getUnsatisfiableClasses(); // This node contains owl:Nothing and all the classes that are equivalent to owl:Nothing - // i.e. the unsatisfiable classes. // We just want to print out the unsatisfiable classes excluding owl:Nothing, and we can // used a convenience method on the node to get these Set<OWLClass> unsatisfiable = bottomNode.getEntitiesMinusBottom(); if (!unsatisfiable.isEmpty()) { System.out.println("The following classes are unsatisfiable: "); for (OWLClass cls : unsatisfiable) { System.out.println(" " + cls); } } else { System.out.println("There are no unsatisfiable classes"); } System.out.println("\n"); // Now we want to query the reasoner for all descendants of vegetarian. Vegetarians are // defined in the // ontology to be animals that don't eat animals or parts of animals. OWLDataFactory fac = manager.getOWLDataFactory(); // Get a reference to the vegetarian class so that we can as the reasoner about it. // The full IRI of this class happens to be: // <http://owl.man.ac.uk/2005/07/sssw/people#vegetarian> OWLClass vegPizza = fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#vegetarian")); // Now use the reasoner to obtain the subclasses of vegetarian. // We can ask for the direct subclasses of vegetarian or all of the (proper) subclasses of // vegetarian. // In this case we just want the direct ones (which we specify by the "true" flag). NodeSet<OWLClass> subClses = reasoner.getSubClasses(vegPizza, true); // The reasoner returns a NodeSet, which represents a set of Nodes. // Each node in the set represents a subclass of vegetarian pizza. A node of classes contains // classes, // where each class in the node is equivalent. For example, if we asked for the // subclasses of some class A and got back a NodeSet containing two nodes {B, C} and {D}, then // A would have // two proper subclasses. One of these subclasses would be equivalent to the class D, and the // other would // be the class that is equivalent to class B and class C. // In this case, we don't particularly care about the equivalences, so we will flatten this // set of sets and print the result Set<OWLClass> clses = subClses.getFlattened(); System.out.println("Subclasses of vegetarian: "); for (OWLClass cls : clses) { System.out.println(" " + cls); } System.out.println("\n"); // In this case, we should find that the classes, cow, sheep and giraffe are vegetarian. Note // that in this // ontology only the class cow had been stated to be a subclass of vegetarian. The fact that // sheep and // giraffe are subclasses of vegetarian was implicit in the ontology (through other things we // had said) // and this illustrates why it is important to use a reasoner for querying an ontology. // We can easily retrieve the instances of a class. In this example we'll obtain the // instances of // the class pet. This class has a full IRI of <http://owl.man.ac.uk/2005/07/sssw/people#pet> // We need to obtain a reference to this class so that we can ask the reasoner about it. OWLClass country = fac.getOWLClass(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#pet")); // Ask the reasoner for the instances of pet NodeSet<OWLNamedIndividual> individualsNodeSet = reasoner.getInstances(country, true); // The reasoner returns a NodeSet again. This time the NodeSet contains individuals. // Again, we just want the individuals, so get a flattened set. Set<OWLNamedIndividual> individuals = individualsNodeSet.getFlattened(); System.out.println("Instances of pet: "); for (OWLNamedIndividual ind : individuals) { System.out.println(" " + ind); } System.out.println("\n"); // Again, it's worth noting that not all of the individuals that are returned were explicitly // stated // to be pets. // Finally, we can ask for the property values (property assertions in OWL speak) for a given // individual // and property. // Let's get the property values for the individual Mick, the full IRI of which is // <http://owl.man.ac.uk/2005/07/sssw/people#Mick> // Get a reference to the individual Mick OWLNamedIndividual mick = fac.getOWLNamedIndividual(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#Mick")); // Let's get the pets of Mick // Get hold of the has_pet property which has a full IRI of // <http://owl.man.ac.uk/2005/07/sssw/people#has_pet> OWLObjectProperty hasPet = fac.getOWLObjectProperty(IRI.create("http://owl.man.ac.uk/2005/07/sssw/people#has_pet")); // Now ask the reasoner for the has_pet property values for Mick NodeSet<OWLNamedIndividual> petValuesNodeSet = reasoner.getObjectPropertyValues(mick, hasPet); Set<OWLNamedIndividual> values = petValuesNodeSet.getFlattened(); System.out.println("The has_pet property values for Mick are: "); for (OWLNamedIndividual ind : values) { System.out.println(" " + ind); } // Notice that Mick has a pet Rex, which wasn't asserted in the ontology. // Finally, let's print out the class hierarchy. // Get hold of the top node in the class hierarchy (containing owl:Thing) // Now print the hierarchy out Node<OWLClass> topNode = reasoner.getTopClassNode(); print(topNode, reasoner, 0); } catch (UnsupportedOperationException exception) { System.out.println("Unsupported reasoner operation."); } catch (OWLOntologyCreationException e) { System.out.println("Could not load the pizza ontology: " + e.getMessage()); } }
public boolean retrieveSolutions(String siteNameHash) { // use the siteNameHash to access a certain Site individual in the ontology // retrieve each Solution individual of this site and use it to re-initialise the Solutions List OwlSolution tempSolution; OwlSolvedHouse tempSolvedHouse; OwlSolvedRoom tempSolvedRoom; // first clear the Solution List contents... this.solutionsList.clear(); OWLIndividual tempSiteIndividual = OWLFactory.getOWLNamedIndividual(":" + siteNameHash, topIxPrefixManager); OWLClassExpression tempSolutionClassExpression = OWLFactory.getOWLClass(":Solution", topIxPrefixManager); Set<OWLObjectPropertyAssertionAxiom> tempSitePropertyAxioms = topIxOnt.getObjectPropertyAssertionAxioms(tempSiteIndividual); Set<OWLIndividual> tempSolutionIndividuals = new HashSet<>(); // Solution individuals for this particular site. will be filled below... Set<OWLIndividual> tempSolvedHouseIndividuals = new HashSet<>(); Set<OWLIndividual> tempSolvedRoomIndividuals = new HashSet<>(); // populate the tempSolutionIndividuals Set<OWLIndividual> // with the Solution individuals that are solutions of the current Site // this block runs through the set of all the object property axioms // that have this site as their subject // and filters out the ones that are of type "hasSolution" for (OWLObjectPropertyAssertionAxiom tempObjPropAssAx : tempSitePropertyAxioms) { OWLObjectProperty tempHasSolutionObjectProperty = OWLFactory.getOWLObjectProperty( IRI.create(topIxOnt.getOntologyID().getOntologyIRI() + "#hasSolution")); if (tempObjPropAssAx.getProperty() == tempHasSolutionObjectProperty) { tempSolutionIndividuals.add(tempObjPropAssAx.getObject()); } } // retrieving the site dimensions for this solution set // (the site remains the same throughout the plethos of solutions). int tempSiteLength = 0; int tempSiteWidth = 0; OWLDataProperty siteHasLengthProp = OWLFactory.getOWLDataProperty(":hasX", topIxPrefixManager); OWLDataProperty siteHasWidthProp = OWLFactory.getOWLDataProperty(":hasY", topIxPrefixManager); Set<OWLDataPropertyAssertionAxiom> tempSiteDataProperties = new HashSet<>(); tempSiteDataProperties = topIxOnt.getDataPropertyAssertionAxioms(tempSiteIndividual); for (OWLDataPropertyAssertionAxiom tempSiteDataProperty : tempSiteDataProperties) { if (tempSiteDataProperty.getProperty() == siteHasLengthProp) { tempSiteLength = tempSiteDataProperty.getObject().parseInteger(); } if (tempSiteDataProperty.getProperty() == siteHasWidthProp) { tempSiteWidth = tempSiteDataProperty.getObject().parseInteger(); } } logger.info(tempSolutionIndividuals.size()); // running every solution individual for/of that particular site in order // to extract the solvedHouse's and the solvedRoom's // via the hasSolvedHouse and hasSolvedRoom properties. int solutionCounter = 0; for (OWLIndividual tempSolutionIndividual : tempSolutionIndividuals) { tempSolution = new OwlSolution(); tempSolution.setSolutionID(new Integer(++solutionCounter)); tempSolution.setSiteLength(new Integer(tempSiteLength)); tempSolution.setSiteWidth(new Integer(tempSiteWidth)); // clearing the contents of these two structuresin order to accommodate the solved entities of // the next solution. tempSolvedHouseIndividuals.clear(); tempSolvedRoomIndividuals.clear(); for (OWLObjectPropertyAssertionAxiom tempObjPropAssAx : topIxOnt.getObjectPropertyAssertionAxioms(tempSolutionIndividual)) { OWLObjectProperty tempHasSolvedHouseObjectProperty = OWLFactory.getOWLObjectProperty( IRI.create(topIxOnt.getOntologyID().getOntologyIRI() + "#hasSolvedHouse")); OWLObjectProperty tempHasSolvedRoomObjectProperty = OWLFactory.getOWLObjectProperty( IRI.create(topIxOnt.getOntologyID().getOntologyIRI() + "#hasSolvedRoom")); if (tempObjPropAssAx.getProperty() == tempHasSolvedHouseObjectProperty) { tempSolvedHouseIndividuals.add(tempObjPropAssAx.getObject()); } else if (tempObjPropAssAx.getProperty() == tempHasSolvedRoomObjectProperty) { tempSolvedRoomIndividuals.add(tempObjPropAssAx.getObject()); } } for (OWLIndividual tempSolvedHouseIndividual : tempSolvedHouseIndividuals) { tempSolvedHouse = new OwlSolvedHouse(); for (OWLDataPropertyAssertionAxiom tempDatPropAssAx : topIxOnt.getDataPropertyAssertionAxioms(tempSolvedHouseIndividual)) { if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasL", topIxPrefixManager))) { // logger.info(tempDatPropAssAx.getObject().parseInteger()); tempSolvedHouse.setSolvedHouseLength(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasW", topIxPrefixManager))) { tempSolvedHouse.setSolvedHouseWidth(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasX", topIxPrefixManager))) { tempSolvedHouse.setSolvedHouseX(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasY", topIxPrefixManager))) { tempSolvedHouse.setSolvedHouseY(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasLiteral", topIxPrefixManager))) { tempSolvedHouse.setSolvedHouseLiteral(tempDatPropAssAx.getObject().getLiteral()); } } // logger.info(tempSolvedHouse.getSolvedHouseX()+" "+tempSolvedHouse.getSolvedHouseY()); tempSolution.getSolvedHouses().add(tempSolvedHouse); } for (OWLIndividual tempSolvedRoomIndividual : tempSolvedRoomIndividuals) { tempSolvedRoom = new OwlSolvedRoom(); for (OWLDataPropertyAssertionAxiom tempDatPropAssAx : topIxOnt.getDataPropertyAssertionAxioms(tempSolvedRoomIndividual)) { if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasL", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomLength(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasW", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomWidth(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasH", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomHeight(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasX", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomX(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasY", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomY(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasZ", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomZ(tempDatPropAssAx.getObject().parseInteger()); } else if (tempDatPropAssAx.getProperty() == (OWLFactory.getOWLDataProperty(":hasLiteral", topIxPrefixManager))) { tempSolvedRoom.setSolvedRoomLiteral(tempDatPropAssAx.getObject().getLiteral()); } } tempSolution.getSolvedRooms().add(tempSolvedRoom); } this.solutionsList.add(tempSolution); } return true; }