Chamar método mais de um vez

Olá galera do GUJ, bom dia.
[color=red]OBSERVAÇÃO[/color]: Galera comentei partes do código abaixo para que vocês possam
entender melhor o que cada parte do meu método faz. Acredito que assim facilite o entendimento do meu código para vocês.

Sendo assim vamos ao problema, mas antes de explica-lo irei fazer um breve resumo do que estou querendo fazer, pra que assim vocês possam ter um melhor entendimento do que estou querendo fazer. :-) Tenho uma classe que retorna a seguinte hierarquia.

Disease
   name
   class
Drug
   name
   indication
   metabolism
   pregnancyCategory
GenericDrug
   affectedOrganism
   chemicalFormula
   genericName
Ingredient
   name
SideEffect
   sideEffectName

Como pode ser notado é uma hierarquia no formato de árvore, onde por exemplo, Disease tem como filhos . O que eu gostaria de fazer era através dessa hierarquia montar consultas SPARQL. Para tal, tenho os seguinte métodos (ainda em desenvolvimento). O código abaixo Monta o SELECT da minha consulta.

public void buildsSelect() throws OWLOntologyCreationException {
        // Carrega a ontologia e o PrefixManager
        try {
            baseLoaded();
        } catch (OWLException erro) {
            System.out.println("Erro: " + erro);
        }

        query = "PREFIX dailymed: <http://www4.wiwiss.fu-berlin.de/dailymed/resource/dailymed/>"
                + "\n" + "PREFIX drugbank: <http://www4.wiwiss.fu-berlin.de/drugbank/resource/drugbank/>"
                + "\n" + "PREFIX sider: <http://www4.wiwiss.fu-berlin.de/sider/resource/sider/> \n\n";
        query += ClausesSparql.SELECT.toString();

        // Aqui adiciono uma classe inicial qualquer da minha hierarquia apenas pra que a consulta seja inicialmente montada
        arrayCurrentClass = new ArrayList<>(); 
        arrayCurrentClass.add("Disease");

            // Aqui acesso as classes e subclasses da minha hierarquia apresentada acima
	    for (Iterator it = buildsHierarchy(ontology).entrySet().iterator(); it.hasNext();) {
            Map.Entry entry = (Map.Entry) it.next();
            String key = pm.getShortForm((OWLEntity) entry.getKey()).replace(":", ""); // Classes
            String value = entry.getValue().toString(); // Subclasses
	    
	    // Aqui percorro o meu array onde a minha classe inicial foi adicionada.
            // A ideia é que a medida que a consulta vá sendo montada, novas classes sejam adicionadas ao meu array.
	    // Irei explicar como isso acontece mais abaixo.
            for (String srtClass : arrayCurrentClass) {
                currentClass = srtClass;
                if (key.equalsIgnoreCase(currentClass)) {
                    if (!value.isEmpty()) {
                        ArrayList<OWLEntity> arrayList = (ArrayList<OWLEntity>) entry.getValue();
                        for (OWLEntity objEntity : arrayList) {
                            String valueKey = pm.getShortForm(objEntity).replace(":", "");
                            query += " ?" + currentClass + "_" + valueKey;
                        }
                    }
                    //System.out.println(query);
                }
            }
        }
}

Após a execução do código acima, o SELECT para Disease fica da seguinte maneira:

PREFIX dailymed: <http://www4.wiwiss.fu-berlin.de/dailymed/resource/dailymed/>
PREFIX drugbank: <http://www4.wiwiss.fu-berlin.de/drugbank/resource/drugbank/>
PREFIX sider: <http://www4.wiwiss.fu-berlin.de/sider/resource/sider/> 

SELECT ?Disease_name ?Disease_class

O código abaixo Monta o WHERE da minha consulta.

public void buildsWhere() throws OWLOntologyCreationException {
        query += "\n" + ClausesSparql.WHERE.toString() + " {";
        String prefix = "ddg";
        
	// Aqui acesso as classes e subclasses da minha hierarquia apresentada acima
	for (Iterator it = buildsHierarchy(ontology).entrySet().iterator(); it.hasNext();) {
            Map.Entry entry = (Map.Entry) it.next();
            String key = pm.getShortForm((OWLEntity) entry.getKey()).replace(":", "");
            String value = entry.getValue().toString();

            if (key.equalsIgnoreCase(currentClass)) {
                if (!value.isEmpty()) {
                    ArrayList<OWLEntity> arrayList = (ArrayList<OWLEntity>) entry.getValue();
                    for (OWLEntity o : arrayList) {
                        //System.out.println("   " + pm.getShortForm(o).replace(":", ""));
                        String valueKey = pm.getShortForm(o).replace(":", "");
                        query += "\n   ?" + currentClass + " "
                                + prefix + ":" + valueKey
                                + " ?" + currentClass + "_" + valueKey + ".";
                    }
                }
            }
        }

	// Aqui verifico se a minha classe "Disease" tem ligação com alguma outra classe.
        // Nesse caso tem com Drug e essa ligação é expressa a partir da tripla: ?Disease ddg:possibleDrug ?Drug
	for (Iterator it = buildsObjectProperty(ontology).iterator(); it.hasNext();) {
            TripleStore ts = (TripleStore) it.next();

            if (currentClass.equals(ts.getDomain())) {
                query += "\n   ?" + ts.getDomain() + " "
                        + prefix + ":" + ts.getObjectProperty()
                        + " ?" + ts.getRange() + ".";
                //+ " ?" + ts.getDomain() + "_" + ts.getRange() + ".";
            }
        }

	// Aqui removo minha classe na qual a consulta foi utilizada para montar a consulta,
        // pra que assim ela não seja utilizada mais de uma vez
	arrayCurrentClass.remove(currentClass);	
        for (Iterator it = buildsObjectProperty(ontology).iterator(); it.hasNext();) {
            TripleStore ts = (TripleStore) it.next();

	   // Aqui adiciono as classes que tem ligações com "Disease" no mesmo array no qual inicialmente adicionei a classe "Disease"
           // Além disso, aqui é onde ta o "X" da questão, pois como já tenho as classes que fazem referência para "Disease"
	   // o que eu gostaria era que o método buildsSelect() e buildsWhere() fossem chamados automaticamente
           // de tal maneira que a consulta fosse remontada tanto com os atributos de "Disease" quanto de "Drug" no Select e no Where     
	   if (currentClass.equals(ts.getDomain()) && !currentClass.equals(ts.getRange())) {
                arrayCurrentClass.add(ts.getRange().toString());
            }
        }
        System.out.println(query);
}

O resultado retornado após o WHERE ter sido montado fica da seguinte maneira.

SELECT ?Disease_name ?Disease_class
WHERE {
   ?Disease ddg:name ?Disease_name.
   ?Disease ddg:class ?Disease_class.
   ?Disease ddg:possibleDrug ?Drug.

Esse último resultado da clausura WHERE (?Disease ddg:possibleDrug ?Drug.) faz referência para a classe Drug em minha hierarquia de classes como eu havia já dito anteriomente.

A chamada recursiva que eu gostaria de fazer era a seguinte maneira:
Quando tivesse uma tripla na minha consulta igual a ?Disease ddg:possibleDrug ?Drug. que faz referência para outra classe,
que todos os seus filhos fossem adicionados no SELECT, além de chamados no WHERE.
E caso a minha classe Drug fizesse referências pra outras classes que tivesse novas chamadas recursivas.

Alguém sabe me dizer o que devo mudar no meu código para fazer com que o mesmo tenha tal comportamento?
Desde de já obrigado pela ajuda de todos.
Abraço.

Topicos relacionados