Set<OntClass> conjClasses = parser.listarClasses();
Set<DatatypeProperty> conjDatatypes = null;
for(OntClass ontClass : conjClasses){
//Instanciar um Concept
Concept tmpConcept = new Concept();
//Adicionar o nome do conceito
tmpConcept.setNome(lowerFirstChar(ontClass.getLocalName()));
//recuperar todos os Datatype properties utilizados pela OntClass
conjDatatypes = parser.listarDatatypeProperties(ontClass);
Iterator<DatatypeProperty> iterator = conjDatatypes.iterator();
/* Verificar se existem instancias declaradas para a classe na ontologia.
* Se nao existir significa que a classe eh abstrata, e o metodo
* setAbstractConcept() deve ser invocado passando o valor TRUE.
*/
if(parser.listarInstancias(ontClass).size() == 0){
tmpConcept.setAbstractConcept(true);
}
/* Para cada DatatypeProperty encontrado criar um objeto
* ConceptAttribute e adiciona-lo a lista de atributos do Concept.
*/
while(iterator.hasNext()){
DatatypeProperty datatype = iterator.next();
ConceptAttribute atrib = new ConceptAttribute();
atrib.setNomeAtributo(lowerFirstChar(datatype.getLocalName()));
atrib.setTipoRange(recuperarDomainsDatatype(datatype));
//TODO interacao com o usuario para decidir se o atributo deve ser considerado
tmpConcept.addAttribute(atrib);
}
/* Recupera a lista de classes que sao subclasses do conceito sendo gerado
* e insere um ConceptAxiom para cada uma delas. Cada ConceptAxioma recebera
* como nome "superClassOf" para que o conceito saiba reconhecer todas as
* suas subclasses.
*
* OBS: isto eh necessario especialmente para quando o conceito eh abstrato,
* jah que as regras que deverao ser geradas sobre o conceito devem indicar
* suas possiveis instanciacoes.
*
*/
Set<OntClass> conjSubclasses = parser.listarSubclasses(ontClass);
if(conjSubclasses.size() != 0){
for(OntClass c: conjSubclasses){
ConceptAxiom axioma = new ConceptAxiom();
axioma.setNome("superClassOf");
axioma.setValor(lowerFirstChar(c.getLocalName()));
tmpConcept.addConceptAxiom(axioma);
}
}
// /* Verificar todas as outras classes da ontologia e apurar se o conceito
// * que esta sendo criado eh disjunto a alguma destas outras classes. Sendo,
// * um axioma "disjointWith" deve ser criado.
// */
// for(OntClass c : conjClasses){
// if(c.getDisjointWith() != null){
// //iterador em cima de todas as classes disjuntas
// Iterator<OntClass> it = c.listDisjointWith();
// OntClass aux = null;
// while(it.hasNext()){
// aux = it.next();
// //Se aux == ontClass entao o conceito (ontClass) e a
// //classe iterada (c) sao disjuntas
// if(aux.getLocalName().equalsIgnoreCase(ontClass.getLocalName())){
// //Criacao do conceito negativo e verificacao para adicao
// Concept conceitoNeg = criarConceitoNegativo(c);
// 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);
// }
// }
// }
// }
/* Recupera todos os axiomas subClassOf da classe, identifica qual
* faz referencia a classe pai e adiciona aos axiomas do conceito.
*
* Ao recuperar a classe pai verifica-se se ela � abstrata. Sendo, os relacionamentos
* sao inseridos no conceito.
*
* Recupera todos os restrictions indicados nos subclassOf restantes
* e adiciona como restricoes no conceito atraves do metodo addRestriction
*
* 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);
}