Renommer les stratégies avec la recherche et le remplacement par lots - Analyse personnalisée

Idéal si vous souhaitez créer rapidement des noms propres et informatifs pour l'ensemble d'une banque de données, cet extrait d'analyse personnalisée vous permet de renommer par lots des stratégies dans StrategyQuant X à l'aide d'une simple fonction rechercher → remplacer (ou simplement rechercher → supprimer).

- Ce qu'il fait

• Fonctionne comme un Analyse personnalisée (Analyse complète de la banque de données).

• Args d'entrée accepte find=>replace ou simplement find pour supprimer.

• Renommer en place dans la banque de données Source sélectionnée.

• Littéral, sensible à la casse match. Soutien \n, \t, \r.

• Idéal pour le nettoyage de masse : suppression des préfixes/suffixes, suppression de mots, normalisation des symboles/horaires/directions.

- Comment installer

1. Éditeur de code → Nouveau → Analyse personnalisée, nommez le fichier CARenameFindReplace
2. Collez le code (ci-dessous) et Compiler.
3. Si nécessaire, redémarrer SQX.

- Comment l'utiliser

1. Custom Project → Task → Analyse personnalisée. (Il peut également être exécuté à l'intérieur d'une banque de données à partir de Banque de données > Outils > Exécuter l'AC).
2. En Analyse de la banque de données complète, sélectionner CARenameFindReplace et choisissez votre Source banque de données.
3. En Args d'entrée saisir l'un des éléments suivants :
   -
   Remplacer : ancien=>nouveau
   Supprimer : ancien
   -
4. Activez l'option 'Filtrer par les résultats de l'analyse personnalisée' pour renommer les stratégies originales. (Si vous désactivez cette option, les stratégies seront dupliquées et seuls les duplicatas seront renommés, sans toucher aux originaux).
5. Exécuter. Tous les noms de stratégie de la banque de données Source sont mis à jour.

- Exemples

• Supprimer le mot "Strategy " (avec espace) :
  Stratégie =>
• Convertit le nom propre de SQX en une étiquette formatée :
  Stratégie =>XAUUSD_H1_L_
• Dénuder les points après une passe de préfixe :
  .=>

Conseil : Effectuez plusieurs passages pour un formatage en plusieurs étapes (par exemple, ajoutez un préfixe, puis supprimez les caractères, puis ajoutez un suffixe). Envisagez de dupliquer d'abord la banque de données si vous voulez pouvoir revenir facilement en arrière.

Code :

package SQ.CustomAnalysis ;

import com.strategyquant.tradinglib.* ;
import com.strategyquant.tradinglib.project.ProjectEngine ;
import com.strategyquant.tradinglib.project.SQProject ;

import java.util.ArrayList ;
import java.util.HashSet ;

public class CARenameFindReplace extends CustomAnalysisMethod {

    public CARenameFindReplace() {
        super("CARenameFindReplace", TYPE_PROCESS_DATABANK) ;
    }

    @Override
    public boolean filterStrategy(String project, String task, String databankName, ResultsGroup rg) throws Exception {
        return true ;
    }

    @Override
    public ArrayList processDatabank(
            String project,
            String task,
            String databankName,
            ArrayList databankRG) jette des exceptions {

        // Lecture d'une seule chaîne d'arguments d'entrée
        String raw = getInputArgs() ;
        if (raw == null) raw = "" ;
        raw = raw.trim() ;

        // Pas d'arguments -> ne rien faire
        if (raw.isEmpty()) {
            return databankRG ;
        }

        // Analyse : "find=>replace" OU juste "find" (remove)
        Chaîne find, repl ;
        int arrow = raw.indexOf("=>") ;
        if (arrow >= 0) {
            find = raw.substring(0, arrow) ;
            repl = raw.substring(arrow + 2) ;
        } else {
            find = raw ;
            repl = "" ;
        }

        find = unescape(find) ;
        repl = unescape(repl) ;

        // Si find est vide, ne rien faire (évite de renommer accidentellement)
        if (find.isEmpty()) {
            return databankRG ;
        }

        SQProject prj = ProjectEngine.get(project) ;
        Databank db = prj.getDatabanks().get(databankName) ;

        // Instantané des originaux pour éviter l'exception de modification simultanée (ConcurrentModificationException)
        ArrayList snapshot = new ArrayList(databankRG) ;

        // Suivi des noms existants afin d'éviter les collisions si nécessaire
        HashSet usedNames = new HashSet() ;
        for (ResultsGroup rg : snapshot) {
            if (rg.getName() != null) usedNames.add(rg.getName()) ;
        }

        // 1) Créer des clones renommés (pas de db.add dans l'itération)
        ArrayList clonesToAdd = new ArrayList() ;

        for (ResultsGroup rg : snapshot) {
            String oldName = rg.getName() ;
            if (oldName == null) continue ;

            String newName = oldName.replace(find, repl) ;

            // Ne dupliquer que si le nom change
            if (!newName.equals(oldName)) {
                // Éviter les collisions de noms exacts (sécurité optionnelle)
                String finalName = makeUniqueName(newName, usedNames) ;

                ResultsGroup newRg = rg.clone() ;
                newRg.setName(finalName) ;

                clonesToAdd.add(newRg) ;
                usedNames.add(finalName) ;
            }
        }

        // 2) Ajouter des clones après l'itération (sûr)
        for (ResultsGroup newRg : clonesToAdd) {
            db.add(newRg, true) ;
        }

        // Retourne les stratégies nouvellement créées (miroir du comportement SQX RenameStrategies)
        return clonesToAdd ;
    }

    private static String makeUniqueName(String baseName, HashSet used) {
        if (!used.contains(baseName)) return baseName ;

        int i = 2 ;
        while (true) {
            String candidate = baseName + "_" + i ;
            if (!used.contains(candidate)) return candidate ;
            i++ ;
        }
    }

    private static String unescape(String s) {
        if (s == null) return "" ;
        return s.replace("\N-", "\N-")
                .replace("\N-", "\N-")
                .replace("\r", "\r") ;
    }
}