*
* OBS: Restrictions sao Superclasses sem LocalName.
*/
if(ontClass.getSuperClass() != null){
Iterator<OntClass> it = ontClass.listSuperClasses(true);
OntClass aux = null;
while(it.hasNext()){
aux = it.next();
if(aux.getLocalName() != null){ //tem LocalName, referencia a classe pai
ConceptAxiom axioma = new ConceptAxiom();
axioma.setNome("subClassOf");
axioma.setValor(lowerFirstChar(aux.getLocalName()));
tmpConcept.addConceptAxiom(axioma);
//Se a super classe for abstrata recupera todos os relacionamentos
List<ConceptRestriction> relacionamentosSup = recuperarRelacionamentosSup(aux, ontClass.getLocalName());
for(ConceptRestriction conRest : relacionamentosSup){
tmpConcept.addConceptRestriction(conRest);
}
}else{ //eh um restriction
Restriction restriction = aux.asRestriction();
ConceptRestriction conRest = recuperarDadosRestriction(restriction, tmpConcept.getNome());
tmpConcept.addConceptRestriction(conRest);
// //Verificar se existe mais de uma classe no range do OP e criar disjoints
// ObjectProperty op = parser.recuperarObjectProperty(conRest.getNomeProperty());
// if(op.getRange().asClass().isUnionClass()){
// UnionClass uniao = op.getRange().asClass().asUnionClass();
// ExtendedIterator<? extends OntClass> iterador = uniao.listOperands();
// while(iterador.hasNext()){
// OntClass classe = (OntClass) iterador.next();
// if(classe.getLocalName().equals(ontClass.getLocalName()) == false){
//
// //Criacao e adicao do conceito negativo a lista de conceitos
// Concept conceitoNeg = criarConceitoNegativo(classe);
// if(isConceptInList(conceitoNeg, conceptsList) == false){
// conceptsList.add(conceitoNeg);
// }
//
// //adiciona a referencia de disjuncao
// ConceptAxiom cAxioma = new ConceptAxiom();
// cAxioma.setNome("disjointWith");
// cAxioma.setValor(lowerFirstChar(conceitoNeg.getNome()));
//
// tmpConcept.addConceptAxiom(cAxioma);
// }
// }
// }
}
}
}
// /*
// * Recupera todos os axiomas DisjointWith do conceito e cria um conceito
// * auxiliar para permitir a negacao.
// *
// * Como o forte nao e capaz de revisar regras com negacao e necessario
// * criar um novo ceonceito que possui a negacao e inclui-lo no FDT.
// *
// * Cria-se entao um conceitoNegacao e um axioma subclassOf relacionando
// * a classe presente ao conceito negado, de forma que a geracao da regra
// * cria um predicado "regraNegacao(A)".
// */
// if(ontClass.getDisjointWith() != null){
// //iterador em cima de todas as classes disjuntas
// Iterator<OntClass> it = ontClass.listDisjointWith();
// OntClass aux = null;
// while(it.hasNext()){
// aux = it.next();
//
// //Criacao e adicao do conceito negativo a lista de conceitos
// Concept conceitoNeg = criarConceitoNegativo(aux);
// if(isConceptInList(conceitoNeg, conceptsList) == false){
// conceptsList.add(conceitoNeg);
// }
//
// //adiciona a referencia de disjuncao
// ConceptAxiom axioma = new ConceptAxiom();
// axioma.setNome("disjointWith");
// axioma.setValor(lowerFirstChar(conceitoNeg.getNome()));
//
// tmpConcept.addConceptAxiom(axioma);
// }
// }
/*
* Se a classe possuir o axioma EquivalentClass indicando sua
* equivalencia a outra classe da ontologia entao ambas deverao
* ser excluidas da revisao, sendo adicionadas ao FDT.
*
* Na geracao do conceito e inserido um axioma equivalentClass na lista
* de axiomas com o valor igual ao nome do conceito ao qual se refere
* a equivalencia. Desta forma sera possivel identificar posteriormente
* os dois conceitos que deverao ser inseridos no FDT.
*/
if(ontClass.getEquivalentClass() != null){
//iterador em cima de todas as classes equivalentes
Iterator<OntClass> it = ontClass.listEquivalentClasses();
OntClass aux = null;
while(it.hasNext()){
aux = it.next();
ConceptAxiom axioma = new ConceptAxiom();
axioma.setNome("equivalentClass");
axioma.setValor(lowerFirstChar(aux.getLocalName()));
tmpConcept.addConceptAxiom(axioma);
}
}
conceptsList.add(tmpConcept);