Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Copyright (C) 2009-2013, Free University of Bozen Bolzano This source code is
    * available under the terms of the Affero General Public License v3.
    * 
    * Please see LICENSE.txt for full license terms, including the availability of
    * proprietary exceptions.
    */
   package it.unibz.krdb.obda.owlapi3;
   
  /*
   * #%L
   * ontop-obdalib-owlapi3
   * %%
   * Copyright (C) 2009 - 2014 Free University of Bozen-Bolzano
   * %%
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * #L%
   */
  
  
  import java.io.File;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
Translates an OWLOntology into ontops internal ontlogy representation. It will ignore all ABox assertions and does a syntactic approximation of the ontology, dropping anything not support by Quest during inference.

Author(s):
Mariano Rodriguez Muro <mariano.muro@gmail.com>
 
 public class OWLAPI3Translator {
 
 
 	private static final OBDADataFactory dfac = OBDADataFactoryImpl.getInstance();
 	private static final OntologyFactory ofac = OntologyFactoryImpl.getInstance();
 
 	private static final Logger log = LoggerFactory.getLogger(OWLAPI3Translator.class);
 
 	/*
 	 * If we need to construct auxiliary subclass axioms for A ISA exists R.C we
 	 * put them in this map to avoid generating too many auxiliary
 	 * roles/classes.
 	 */
 
 	int auxRoleCounter = 0;
 
 	public OWLAPI3Translator() {
 
 	}

Load all the ontologies into a single translated merge.

Parameters:
ontologies
Returns:
Throws:
java.lang.Exception
 
 	public Ontology mergeTranslateOntologies(Set<OWLOntologyontologiesthrows Exception {
 		/*
 		 * We will keep track of the loaded ontologies and tranlsate the TBox
 		 * part of them into our internal represntation
 		 */
 		String uri = "http://it.unibz.krdb.obda/Quest/auxiliaryontology";
 
 		Ontology translatedOntologyMerge = .createOntology(uri);
 
 		.debug("Load ontologies called. Translating ontologies.");
 		OWLAPI3Translator translator = new OWLAPI3Translator();
 		// Set<URI> uris = new HashSet<URI>();
 
 		Ontology translation = .createOntology(uri);
 		for (OWLOntology onto : ontologies) {
 			// uris.add(onto.getIRI().toURI());
 			Ontology aux = translator.translate(onto);
 			translation.addConcepts(aux.getConcepts());
 			translation.addRoles(aux.getRoles());
 			translation.addAssertions(aux.getAssertions());
 			translation.getABox().addAll(aux.getABox());
 		}
 		/* we translated successfully, now we append the new assertions */
 
 		translatedOntologyMerge = translation;
 
 		// translatedOntologyMerge.addAssertions(translation.getAssertions());
 		// translatedOntologyMerge.addConcepts(new
 		// ArrayList<ClassDescription>(translation.getConcepts()));
 		// translatedOntologyMerge.addRoles(new
 		// ArrayList<Property>(translation.getRoles()));
 		// translatedOntologyMerge.saturate();
 
 		.debug("Ontology loaded: {}"translatedOntologyMerge);
 
 		return translatedOntologyMerge;
 
 	}
 
 	public Predicate getPredicate(OWLEntity entity) {
 		Predicate p = null;
 		if (entity instanceof OWLClass) {
 			/* We ignore TOP and BOTTOM (Thing and Nothing) */
 			if (((OWLClassentity).isOWLThing() || ((OWLClassentity).isOWLNothing()) {
 				return null;
 			}
 			String uri = entity.getIRI().toString();
 
 			p = .getClassPredicate(uri);
 		} else if (entity instanceof OWLObjectProperty) {
 			String uri = entity.getIRI().toString();
 
 		} else if (entity instanceof OWLDataProperty) {
 			String uri = entity.getIRI().toString();
 
 		}
 		return p;
 	}
 
 	public Ontology translate(OWLOntology owlthrows PunningException {
 		// ManchesterOWLSyntaxOWLObjectRendererImpl rend = new
 		// ManchesterOWLSyntaxOWLObjectRendererImpl();
 
 		OWL2QLProfile owlprofile = new OWL2QLProfile();
 
 		OWLProfileReport report = owlprofile.checkOntology(owl);
 		Set<OWLAxiomaxiomIgnoresOWL2QL = new HashSet<OWLAxiom>();
 
 		if (!report.isInProfile()) {
 			.warn("WARNING. The current ontology is not in the OWL 2 QL profile.");
 			try {
 				File profileReport = new File("quest-profile-report.log");
 				if (profileReport.canWrite()) {
 					BufferedWriter bf = new BufferedWriter(new FileWriter(profileReport));
 					bf.write(report.toString());
 					bf.flush();
 					bf.close();
 				}
 			} catch (Exception e) {
 
 			}
 			// log.warn(report.toString());
 			// for (OWLProfileViolation violation : report.getViolations())
 			// axiomIgnoresOWL2QL.add(violation.getAxiom());
 		}
 
 		// Ontology dl_onto =
 		// ofac.createOntology((owl.getOntologyID().getOntologyIRI().toString()));
 		Ontology dl_onto = .createOntology("http://www.unibz.it/ontology");
 
 		HashSet<Stringobjectproperties = new HashSet<String>();
 		HashSet<Stringdataproperties = new HashSet<String>();
 		HashSet<Stringclasses = new HashSet<String>();
 
 		/*
 		 * First we add all definitions for classes and roles
 		 */
 		Set<OWLEntityentities = owl.getSignature();
 		Iterator<OWLEntityeit = entities.iterator();
 
 		HashSet<StringpunnedPredicates = new HashSet<String>();
 
 		while (eit.hasNext()) {
 			OWLEntity entity = eit.next();
 			Predicate p = getPredicate(entity);
 			if (p == null)
 				continue;
 
 			/*
 			 * When we register predicates punning is not allowed between data
 			 * and object properties
 			 */
 
 			if (p.isClass()) {
 				dl_onto.addConcept(p);
 
 			} else {
 				if (p.isObjectProperty()) {
 					if (dataproperties.contains(p.getName().toString())) {
 						punnedPredicates.add(p.getName().toString());
 					} else {
 						objectproperties.add(p.getName().toString());
 						dl_onto.addRole(p);
 					}
 				} else {
 					if (objectproperties.contains(p.getName().toString())) {
 						punnedPredicates.add(p.getName().toString());
 					} else {
 						dataproperties.add(p.getName().toString());
 						dl_onto.addRole(p);
 					}
 				}
 			}
 		}
 
 		/*
 		 * Generating a WARNING about all punned predicates which have been
 		 * ignored
 		 */
 		if (!punnedPredicates.isEmpty()) {
 			.warn("Quest can become unstable with properties declared as both, data and object property. Offending properties: ");
 			for (String predicates : punnedPredicates) {
 				.warn("  " + predicates);
 			}
 		}
 
 		Set<OWLAxiomaxioms = owl.getAxioms();
 		Iterator<OWLAxiomit = axioms.iterator();
 		while (it.hasNext()) {
 
 			OWLAxiom axiom = it.next();
 
 			if (axiomIgnoresOWL2QL.contains(axiom)) {
 				/*
 				 * This axiom is not part of OWL 2 QL according to the OWLAPI,
 				 * we need to ignore it
 				 */
 				continue;
 			}

Important to use the negated normal form of the axioms, and not the simple ones.
 
 			axiom = axiom.getNNF();
 
 			try {
 				if (axiom instanceof OWLEquivalentClassesAxiom) {
 						throw new TranslationException();
 
 					Set<OWLClassExpressionequivalents = aux.getClassExpressions();
 
 					addConceptEquivalences(dl_ontovec);
 
 				} else if (axiom instanceof OWLSubClassOfAxiom) {
 
 
 					addSubclassAxioms(dl_ontosubDescriptionsuperDescriptions);
 
 				} else if (axiom instanceof OWLDataPropertyDomainAxiom) {
 
 
 
 					addSubclassAxioms(dl_ontosubclasssuperDescriptions);
 
 				} else if (axiom instanceof OWLDataPropertyRangeAxiom) {
 
 
 					OWLDatatype rangeDatatype = aux.getRange().asOWLDatatype();
 
 					if (rangeDatatype.isBuiltIn()) {
 
 						Predicate.COL_TYPE columnType = getColumnType(rangeDatatype);
 						DataType datatype = .createDataType(.getTypePredicate(columnType));
 						addSubclassAxiom(dl_ontosubclassdatatype);
 					} else {
 						.warn("Ignoring range axiom since it refers to a non-supported datatype: " + axiom.toString());
 					}
 
 				} else if (axiom instanceof OWLSubDataPropertyOfAxiom) {
 
 
 
 					dl_onto.addAssertion(roleinc);
 
 				} else if (axiom instanceof OWLEquivalentDataPropertiesAxiom) {
 
 						throw new TranslationException();
 
 					addRoleEquivalences(dl_ontovec);
 
 				} else if (axiom instanceof OWLEquivalentObjectPropertiesAxiom) {
 
 						throw new TranslationException();
 
 					addRoleEquivalences(dl_ontovec);
 
 				} else if (axiom instanceof OWLFunctionalDataPropertyAxiom) {
 						throw new TranslationException();
 
 					dl_onto.addAssertion(funct);
 
 				} else if (axiom instanceof OWLInverseObjectPropertiesAxiom) {
 						throw new TranslationException();
 
 					Property role1 = getRoleExpression(exp1);
 					Property role2 = getRoleExpression(exp2);
 
 					Property invrole1 = .createProperty(role1.getPredicate(), !role1.isInverse());
 					Property invrole2 = .createProperty(role2.getPredicate(), !role2.isInverse());
 
 
 					dl_onto.addAssertion(inc1);
 					dl_onto.addAssertion(inc2);
 
 				} else if (axiom instanceof OWLSymmetricObjectPropertyAxiom) {
 						throw new TranslationException();
 					Property role = getRoleExpression(exp1);
 					Property invrole = .createProperty(role.getPredicate(), !role.isInverse());
 
 
 					dl_onto.addAssertion(symm);
 
 				} else if (axiom instanceof OWLObjectPropertyDomainAxiom) {
 
 
 
 					addSubclassAxioms(dl_ontosubclasssuperDescriptions);
 
 				} else if (axiom instanceof OWLObjectPropertyRangeAxiom) {
 
 
 
 					addSubclassAxioms(dl_ontosubclasssuperDescriptions);
 
 				} else if (axiom instanceof OWLSubObjectPropertyOfAxiom) {
 
 
 
 					dl_onto.addAssertion(roleinc);
 
 				} else if (axiom instanceof OWLFunctionalObjectPropertyAxiom) {
 						throw new TranslationException();
 
 					dl_onto.addAssertion(funct);
 					
 				} else if (axiom instanceof OWLInverseFunctionalObjectPropertyAxiom) {
 						throw new TranslationException();
 					Property invrole = .createProperty(role.getPredicate(), !role.isInverse());
 
 					dl_onto.addAssertion(funct);
 
 				} else if (axiom instanceof OWLDisjointClassesAxiom) {
 					for (OWLClassExpression disjClass : aux.getClassExpressionsAsList()) {
 						if (!(disjClass instanceof OWLClass))
 						throw new TranslationException("Invalid class expression in disjoint class axiom: "+disjClass.toString());
 					}
 					Set<OWLClassdisjointClasses = aux.getClassesInSignature();
 					Iterator<OWLClassiter = disjointClasses.iterator();
 					if (!iter.hasNext())
 						throw new TranslationException();
 					OClass c1 = .createClass(iter.next().toStringID());
 					OClass c2 = .createClass(iter.next().toStringID());
 					
 					dl_onto.addAssertion(disj);
 							
 				} else if (axiom instanceof OWLDisjointDataPropertiesAxiom) {
 					Iterator<OWLDataPropertyiter = disjointProps.iterator();
 					if (!iter.hasNext())
 						throw new TranslationException();
 					
 					dl_onto.addAssertion(disj);
 					
 				} else if (axiom instanceof OWLDisjointObjectPropertiesAxiom) {
 					Iterator<OWLObjectPropertyiter = disjointProps.iterator();
 					if (!iter.hasNext())
 						throw new TranslationException();
 					
 					dl_onto.addAssertion(disj);
 				
 				
 				} else if (axiom instanceof OWLIndividualAxiom) {
 					Assertion translatedAxiom = translate((OWLIndividualAxiom)axiom);
 					if (translatedAxiom != null)
 						dl_onto.addAssertion(translatedAxiom);
 					
 				} else if (axiom instanceof OWLAnnotationAxiom) {
 					/*
 					 * Annotations axioms are intentionally ignored by the
 					 * translator
 					 */
 				} else if (axiom instanceof OWLDeclarationAxiom) {
 					OWLEntity entity = owld.getEntity();
 					if (entity instanceof OWLClass) {
 						if (!entity.asOWLClass().isOWLThing()) {
 
 							String uri = entity.asOWLClass().getIRI().toString();
 						}
 					} else if (entity instanceof OWLObjectProperty) {
 						String uri = entity.asOWLObjectProperty().getIRI().toString();
 					} else if (entity instanceof OWLDataProperty) {
 						String uri = entity.asOWLDataProperty().getIRI().toString();
 					} else if (entity instanceof OWLIndividual) {
 						/*
 						 * NO OP, individual declarations are ignored silently
 						 * during TBox translation
 						 */
 					} else {
 						.warn("Ignoring declartion axiom: {}"axiom);
 					}
 
 					/*
 					 * Annotations axioms are intentionally ignored by the
 					 * translator
 					 */
 				}
 				// else if (axiom instanceof OWLImportsDeclaration) {
 				// /*
 				// * Imports
 				// */
 				// }
 				else {
 					.warn("Axiom not yet supported by Quest: {}"axiom.toString());
 				}
 			} catch (TranslationException e) {
 				.warn("Axiom not yet supported by Quest: {}"axiom.toString());
 			}
 		}
 		return dl_onto;
 	}
 
 	private void addSubclassAxiom(Ontology dl_ontoClassDescription subDescriptionClassDescription superDescription) {
 		if (superDescription == null || subDescription == null) {
 			.warn("NULL: {} {}"subDescriptionsuperDescription);
 		}
 
 		if (superDescription instanceof BasicClassDescription) {
 
 			/* We ignore TOP and BOTTOM (Thing and Nothing) */
 			if (superDescription instanceof OClass) {
 				OClass classDescription = (OClasssuperDescription;
 				if (classDescription.toString().equals("http://www.w3.org/2002/07/owl#Thing")) {
 					return;
 				}
 			}
 			SubClassAxiomImpl inc = (SubClassAxiomImpl.createSubClassAxiom(subDescriptionsuperDescription);
 			dl_onto.addAssertion(inc);
 		} else {
 			// log.debug("Generating encoding for {} subclassof {}",
 			// subDescription, superDescription);
 
 			/*
 			 * We found an existential, we need to get an auxiliary set of
 			 * subClassAssertion. Remember, each \exists R.A might have an
 			 * encoding using existing two axioms. \exists R'^- subClassof A, R'
 			 * subRoleOf R.
 			 */
 			List<SubDescriptionAxiomaux = .get(superDescription);
 			PropertySomeRestriction auxclass = null;
 			if (aux == null) {
 				/*
 				 * no auxiliary subclass assertions found for this exists R.A,
 				 * creating a new one
 				 */
 				Predicate role = null;
 				BasicClassDescription filler = null;
 				boolean isInverse = false;
 
 				if (superDescription instanceof PropertySomeClassRestriction) {
 					role = eR.getPredicate();
 					filler = eR.getFiller();
 					isInverse = eR.isInverse();
 				} else if (superDescription instanceof PropertySomeDataTypeRestrictionImpl) {
 					role = eR.getPredicate();
 					filler = eR.getFiller();
 					isInverse = eR.isInverse();
 				}
 
 
 				PropertySomeRestriction propertySomeRestriction = .getPropertySomeRestriction(auxRole.getPredicate(), isInverse);
 				auxclass = propertySomeRestriction;
 
 				/* Creating the new subrole assertions */
 						.createSubPropertyAxiom(auxRole.createProperty(rolefalse)); // Roman:
 																							// was
 																							// isInverse
 																							// in
 																							// place
 																							// of
 																							// false
 				/* Creatin the range assertion */
 				PropertySomeRestriction propertySomeRestrictionInv = .getPropertySomeRestriction(auxRole.getPredicate(), !isInverse);
 
 				SubClassAxiomImpl subclass = (SubClassAxiomImpl.createSubClassAxiom(propertySomeRestrictionInvfiller);
 				aux.add(subclass);
 				aux.add(subrole);
 
 				.put(superDescriptionaux);
 
 				dl_onto.addAssertion(subclass);
 				dl_onto.addAssertion(subrole);
 			} else {
 				/*
 				 * The encoding already exists, so we retrieve it, and get the
 				 * existsR that we need for the extra axiom
 				 */
 				SubClassAxiomImpl axiom1 = (SubClassAxiomImplaux.get(0);
 				PropertySomeRestriction propertySomeInv = (PropertySomeRestrictionaxiom1.getSub();
 						!propertySomeInv.isInverse());
 				auxclass = propertySome;
 			}
 
 			SubClassAxiomImpl inc = (SubClassAxiomImpl.createSubClassAxiom(subDescriptionauxclass);
 			dl_onto.addAssertion(inc);
 		}
 	}
 
 	private void addSubclassAxioms(Ontology dl_ontoClassDescription subDescriptionList<ClassDescriptionsuperDescriptions) {
 		for (ClassDescription superDescription : superDescriptions) {
 			addSubclassAxiom(dl_ontosubDescriptionsuperDescription);
 		}
 	}
 
 		List<ClassDescriptiondescriptions = new LinkedList<ClassDescription>();
 		for (OWLClassExpression OWLClassExpression : owlExpressions) {
 			descriptions.add(getSubclassExpression(OWLClassExpression));
 		}
 		return descriptions;
 	}
 
 		Property role = null;
 
 		if (rolExpression instanceof OWLObjectProperty) {
 			role = .createObjectProperty((rolExpression.asOWLObjectProperty().getIRI().toString()));
 		} else if (rolExpression instanceof OWLObjectInverseOf) {
 				throw new TranslationException();
 			OWLObjectInverseOf aux = (OWLObjectInverseOfrolExpression;
 		} else {
 			throw new TranslationException();
 		}
 		return role;
 
 	}
 
 	private void addConceptEquivalences(Ontology ontologyList<ClassDescriptionroles) {
 		for (int i = 0; i < roles.size(); i++) {
 			for (int j = i + 1; j < roles.size(); j++) {
 				ClassDescription subclass = roles.get(i);
 				ClassDescription superclass = roles.get(j);
 				SubClassAxiomImpl inclusion1 = (SubClassAxiomImpl.createSubClassAxiom(subclasssuperclass);
 				SubClassAxiomImpl inclusion2 = (SubClassAxiomImpl.createSubClassAxiom(superclasssubclass);
 				ontology.addAssertion(inclusion1);
 				ontology.addAssertion(inclusion2);
 			}
 		}
 	}
 
 	private void addRoleEquivalences(Ontology ontologyList<Propertyroles) {
 		for (int i = 0; i < roles.size(); i++) {
 			for (int j = i + 1; j < roles.size(); j++) {
 				Property subrole = roles.get(i);
 				Property superole = roles.get(j);
 				SubPropertyAxiomImpl inclusion1 = (SubPropertyAxiomImpl.createSubPropertyAxiom(subrolesuperole);
 				SubPropertyAxiomImpl inclusion2 = (SubPropertyAxiomImpl.createSubPropertyAxiom(superolesubrole);
 				ontology.addAssertion(inclusion1);
 				ontology.addAssertion(inclusion2);
 			}
 		}
 	}
 
 		List<Propertyresult = new LinkedList<Property>();
 		for (OWLObjectPropertyExpression rolExpression : rolExpressions) {
 			result.add(getRoleExpression(rolExpression));
 		}
 		return result;
 	}
 
 		List<Propertyresult = new LinkedList<Property>();
 		for (OWLDataPropertyExpression rolExpression : rolExpressions) {
 			result.add(getRoleExpression(rolExpression));
 		}
 		return result;
 	}
 
 		Property role = null;
 
 		if (rolExpression instanceof OWLDataProperty) {
 			role = .createDataProperty((rolExpression.asOWLDataProperty().getIRI().toString()));
 		} else {
 			throw new TranslationException();
 		}
 		return role;
 
 	}
 
 		if (owlExpression instanceof OWLObjectIntersectionOf) {
 				throw new TranslationException();
 			}
 			OWLObjectIntersectionOf intersection = (OWLObjectIntersectionOfowlExpression;
 			Set<OWLClassExpressionoperands = intersection.getOperands();
 			for (OWLClassExpression operand : operands) {
 				result.addAll(getSuperclassExpressions(operand));
 			}
 		} else if (owlExpression instanceof OWLObjectSomeValuesFrom) {
 				throw new TranslationException();
 			}
 			OWLObjectSomeValuesFrom someexp = (OWLObjectSomeValuesFromowlExpression;
 			OWLObjectPropertyExpression property = someexp.getProperty();
 			OWLClassExpression filler = someexp.getFiller();
 			if (!(filler instanceof OWLClass)) {
 				throw new TranslationException();
 			}
 			if (filler.isOWLThing()) {
 				result.add(getSubclassExpression(owlExpression));
 			} else {
 				Property role = getRoleExpression(property);
 				result.add(cd);
 			}
 		} else if (owlExpression instanceof OWLDataSomeValuesFrom) {
 				throw new TranslationException();
 			}
 			OWLDataSomeValuesFrom someexp = (OWLDataSomeValuesFromowlExpression;
 			OWLDataPropertyExpression property = someexp.getProperty();
 			OWLDataRange filler = someexp.getFiller();
 
 			if (filler.isTopDatatype()) {
 				Property role = getRoleExpression(property);
 				result.add(cd);
 			} else if (filler instanceof OWLDatatype) {
 				Property role = getRoleExpression(property);
 				result.add(cd);
 			}
 		} else {
 			result.add(getSubclassExpression(owlExpression));
 		}
 		return result;
 	}
 
 		OWLDatatype owlDatatype = (OWLDatatypefiller;
 		COL_TYPE datatype = getColumnType(owlDatatype);
 	}
 
 		ClassDescription cd = null;
 		if (owlExpression instanceof OWLClass) {
 			String uri = ((OWLClassowlExpression).getIRI().toString();
 			cd = .createClass(p);
 
 		} else if (owlExpression instanceof OWLDataMinCardinality) {
 				throw new TranslationException();
 			OWLDataMinCardinality rest = (OWLDataMinCardinalityowlExpression;
 			int cardinatlity = rest.getCardinality();
 			OWLDataRange range = rest.getFiller();
 			if (cardinatlity != 1 || range != null) {
 				throw new TranslationException();
 			}
 			cd = .getPropertySomeRestriction(attributefalse);
 
 		} else if (owlExpression instanceof OWLObjectMinCardinality) {
 				throw new TranslationException();
 			int cardinatlity = rest.getCardinality();
 			OWLClassExpression filler = rest.getFiller();
 			if (cardinatlity != 1) {
 				throw new TranslationException();
 			}
 
 			if (!filler.isOWLThing()) {
 				throw new TranslationException();
 			}
 			String uri = propExp.getNamedProperty().getIRI().toString();
 
 			if (propExp instanceof OWLObjectInverseOf) {
 				cd = .getPropertySomeRestriction(roletrue);
 			} else {
 				cd = .getPropertySomeRestriction(rolefalse);
 			}
 
 		} else if (owlExpression instanceof OWLObjectSomeValuesFrom) {
 				throw new TranslationException();
 			OWLClassExpression filler = rest.getFiller();
 
 			if (!filler.isOWLThing()) {
 				throw new TranslationException();
 			}
 			String uri = propExp.getNamedProperty().getIRI().toString();
 
 			if (propExp instanceof OWLObjectInverseOf) {
 				cd = .getPropertySomeRestriction(roletrue);
 			} else {
 				cd = .getPropertySomeRestriction(rolefalse);
 			}
 		} else if (owlExpression instanceof OWLDataSomeValuesFrom) {
 				throw new TranslationException();
 			OWLDataSomeValuesFrom rest = (OWLDataSomeValuesFromowlExpression;
 			OWLDataRange filler = rest.getFiller();
 
 			if (!filler.isTopDatatype()) {
 				throw new TranslationException();
 			}
 			String uri = propExp.getIRI().toString();
 			cd = .getPropertySomeRestriction(rolefalse);
 		}
 
 		if (cd == null) {
 			throw new TranslationException();
 		}
 		return cd;
 	}
 
 	private class TranslationException extends Exception {

 
 		private static final long serialVersionUID = 7917688953760608030L;
 
 		public TranslationException() {
 			super();
 		}
 
 		public TranslationException(String msg) {
 			super(msg);
 		}
 
 	}
 
 		return translate(axiomnull);
 	}

This will translate an OWLABox assertion into our own abox assertions. The functioning is straight forward except for the equivalenceMap. The equivalenceMap is used to align the ABox assertions with n alternative vocabulary. The equivalence map relates a Class or Role with another Class or Role (or inverse Role) that should be used instead of the original to create the ABox assertions. For example, if the equivalenceMap has the mapping hasFather -> inverse(hasChild), then, if the ABox assertions is "hasFather(mariano,ramon)", the translator will return "hasChild(ramon,mariano)". If there is no equivalence mapping for a given class or property, the translation is straight forward. If the map is empty or it is null, the translation is straight forward.

Parameters:
axiom
equivalenceMap
Returns:
 
 	public Assertion translate(OWLIndividualAxiom axiomMap<PredicateDescriptionequivalenceMap) {
 
 		if (axiom instanceof OWLClassAssertionAxiom) {
 
 			/*
 			 * Class assertions
 			 */
 
 			OWLClassExpression classExpression = assertion.getClassExpression();
 			if (!(classExpression instanceof OWLClass) || classExpression.isOWLThing() || classExpression.isOWLNothing())
 				return null;
 
 			OWLClass namedclass = (OWLClassclassExpression;
 			OWLIndividual indv = assertion.getIndividual();
 
 			if (indv.isAnonymous()) {
 				throw new RuntimeException("Found anonymous individual, this feature is not supported");
 			}
 
 			Predicate classproperty = .getClassPredicate((namedclass.getIRI().toString()));
 
 			Description equivalent = null;
 			if (equivalenceMap != null)
 				equivalent = equivalenceMap.get(classproperty);
 
 			if (equivalent == null)
 				return .createClassAssertion(classpropertyc);
 			else {
 				return .createClassAssertion(((OClassequivalent).getPredicate(), c);
 			}
 
 		} else if (axiom instanceof OWLObjectPropertyAssertionAxiom) {
 
 			/*
 			 * Role assertions
 			 */
 
 			OWLObjectPropertyExpression propertyExperssion = assertion.getProperty();
 
 			String property = null;
 			OWLIndividual subject = null;
 			OWLIndividual object = null;
 
 			if (propertyExperssion instanceof OWLObjectProperty) {
 				OWLObjectProperty namedclass = (OWLObjectPropertypropertyExperssion;
 				property = namedclass.getIRI().toString();
 
 				subject = assertion.getSubject();
 				object = assertion.getObject();
else if (propertyExperssion instanceof OWLObjectInverseOf) {
				OWLObjectProperty namedclass = ((OWLObjectInverseOfpropertyExperssion).getInverse().getNamedProperty();
				property = namedclass.getIRI().toString();
				subject = assertion.getObject();
				object = assertion.getSubject();
			if (subject.isAnonymous()) {
				throw new RuntimeException("Found anonymous individual, this feature is not supported");
			if (object.isAnonymous()) {
				throw new&