Implémentation de la classe Java pour la recherche avancée de designs

Après avoir instancié le point d'extension com.ibm.pdp.maf.rpp.mafAdvancedSearchPattern, vous devez coder en Java la classe qui implémente ses traitements. Elle reçoit le paramétrage du pattern et l'applique aux instances concernées par le pattern. Elle contribue à la constitution de la liste des résultats.

Procédure

  1. Ouvrez le plug-in dédié à la recherche avancée de designs depuis la vue Explorateur de packages de la perspective Développement de plug-in.
  2. Créez la classe Java indiquée dans l'instanciation du point d'extension. Dans l'assistant de création, vous devez indiquer les éléments suivants :
    1. Donnez à la classe le nom indiqué dans le paramètre class du point d'extension, en respectant les majuscules et les minuscules.
    2. Indiquez la classe MAFAbstractAdvancedSearchPattern en tant que superclasse de la nouvelle classe. La spécification de cette superclasse est fortement recommandée car elle permet de gérer la compatibilité ascendante lors des évolutions de l'API de l’interface et elle offre des API de confort sur le paramétrage du pattern.
    3. Assurez-vous que l'option Méthodes abstraites héritées est sélectionnée. Vous pourrez ainsi facilement utiliser les méthodes abstraites de la superclasse.

    Vous êtes maintenant prêt à coder les traitements de la classe Java.

  3. Au début du code, assurez-vous que toutes les méthodes nécessaires aux traitements sont accessibles à la nouvelle classe.
    1. Tous les patterns et toutes les classes nécessaires doivent être importés. Par exemple, si vous codez une classe relative à une recherche sur les Programmes, vous devez importer le pattern des Programmes et le pattern de recherche avancée. Le pattern com.ibm.pdp.maf.rpp.search.IMAFAdvancedSearchPattern suffit mais il est fortement recommandé d'implémenter le pattern com.ibm.pdp.maf.rpp.search.MAFAbstractAdvancedSearchPattern.

      Le début du code d'une classe pour une recherche sur les Programmes doit donc comporter les lignes suivantes :

      import java.util.Map;
      
      import com.ibm.pdp.maf.rpp.pac.program.Program;
      import com.ibm.pdp.maf.rpp.search.IMAFAdvancedSearchPattern;
      import com.ibm.pdp.maf.rpp.search.MAFAbstractAdvancedSearchPattern;
    2. La nouvelle classe doit avoir été déclarée en tant que sous-classe de la superclasse MAFAbstractAdvancedSearchPattern. La ligne suivante doit donc apparaître pour la classe ProgramByMacroCallNumber par exemple après les lignes d'import :
    public class ProgramByMacroCallNumber extends MAFAbstractAdvancedSearchPattern {
    …
  4. Obligatoire : Implémentez le critère d'extraction avec la méthode suivante :
    public boolean accept(Object radicalElement, Map<String, Object> parameters,
    			StringBuilder decoration)

    Le paramètre decoration permet de personnaliser la présentation de la vue de résultat en mode hiérarchique. Il ajoute l'élément ayant permis de détecter chaque instance entre parenthèses après le nom de l'instance.

  5. Facultatif : Implémentez la méthode qui contrôle la validité des paramètres :
    public boolean checkParameters(Map<String, Object> parameters,
     StringBuilder errorMessage)

Exemple

L'exemple suivant illustre l'implémentation de la classe ProgramByPgmID, qui liste les instances de Programmes d'après leur code programme généré. Cette classe implémente un pattern de type STRING.
public class ProgramByPgmID extends MAFAbstractAdvancedSearchPattern {

    public boolean accept(Object radicalElement, Map<String, Object> parameters, StringBuilder decoration) {
        if (!(radicalElement instanceof Program))
            return false;

        Program program = (Program) radicalElement;
        String expression = (String) parameters.get(IMAFAdvancedSearchPattern._STRING_EXPRESSION);
        boolean caseSensitive = (Boolean) parameters.get(IMAFAdvancedSearchPattern._CASE_SENSITIVE);

        Pattern pattern = getPattern(expression, caseSensitive);
        if (pattern.matcher(program.getProgramId()).matches()) {
            decoration.append(program.getProgramId());
            return true;
        }
        return false;
    }
}
L'exemple suivant illustre l'implémentation de la classe ProgramByMacroCallNumber, qui liste les instances de Programmes d'après le nombre de leurs appels de Macros. Cette classe implémente un pattern de type INTEGER.
public ProgramByMacroCallNumber() {
    }

    public boolean accept(Object radicalElement, Map<String, Object> parameters, StringBuilder decoration) {
        if (!(radicalElement instanceof Program))
            return false;

        int value = (Integer) parameters.get(IMAFAdvancedSearchPattern._INTEGER_VALUE);
        String operand = (String) parameters.get(IMAFAdvancedSearchPattern._INTEGER_OPERAND);

        Program program = (Program) radicalElement;
        int size = program.getCPLines().size();

        switch (operand) {
        case IMAFAdvancedSearchPattern._LOWER:
            return size < value;
        case IMAFAdvancedSearchPattern._LOWER_EQUAL:
            return size <= value;
        case IMAFAdvancedSearchPattern._EQUAL:
            return size == value;
        case IMAFAdvancedSearchPattern._GREATER_EQUAL:
            return size >= value;
        case IMAFAdvancedSearchPattern._GREATER:
            return size > value;
        }
        return false;
    }
}
L'exemple suivant illustre l'implémentation de la classe ProgramNameEqualsPgmID, qui liste les instances de Programmes dont le nom et le code programme généré sont identiques. Cette classe implémente un pattern de type BOOLEAN.
public class ProgramNameEqualsPgmID extends MAFAbstractAdvancedSearchPattern {

    public boolean accept(Object radicalElement, Map<String, Object> parameters, StringBuilder decoration) {
        if (!(radicalElement instanceof Program))
            return false;

        Program program = (Program) radicalElement;

        if (program.getName().equals(program.getProgramId()))
            return true;
        return false;
    }
}
L'exemple suivant illustre le début de l'implémentation de la classe ProgramMultiCriteria, qui liste les instances de Programmes selon plusieurs critères. Cet exemple comprend trois critères : une chaîne de caractères, un nombre et un booléen. Le détail de l'implémentation de chaque paramètre n'est pas indiqué car il est très variable. Cette classe implémente un pattern de type COMPOSITE.
public class ProgramMultiCriteria extends MAFAbstractAdvancedSearchPattern {

    public ProgramMultiCriteria() {
    }

    public boolean accept(Object radicalElement, Map<String, Object> parameters, StringBuilder decoration) {
        if (!(radicalElement instanceof Program))
            return false;

        String stringParameter = (String) parameters.get("parameter1");
        Integer integerParameter = (Integer) parameters.get("parameter2");
        Boolean booleanParameter = (Boolean) parameters.get("parameter3");

        Program program = (Program) radicalElement;
        // ...

        return true;
    }
}

Que faire ensuite

Personnalisez la vue de résultat et testez le fonctionnement de la recherche avancée.

Vos commentaires