Renommer des stratégies par lot

Idéal si vous souhaitez créer rapidement des noms clairs et structurés sur l'ensemble d'une databank – ce snippet de Custom Analysis vous permet de renommer en bloc des stratégies dans StrategyQuant X à l'aide d'un simple rechercher → remplacer (ou simplement rechercher → supprimer).

— Fonctionnalités

• S'exécute en tant que Custom Analysis (analyse complète de la databank).

• Input args accepte find=>replace or just find to remove.

• Renomme directement dans la databank source sélectionnée.

• Correspondance littérale, sensible à la casse. Prend en charge \n, \t, \r.

• Parfait pour le nettoyage massif : supprimer les préfixes/suffixes, éliminer des mots, standardiser les symboles/unités de temps/directions.

— Installation

1. Code Editor → New → Custom Analysis, nommez le fichier CARenameFindReplace
2. Collez le code (ci-dessous) et cliquez sur Compile.
3. Si nécessaire, redémarrez SQX.

— Utilisation

1. Custom Project → Task → Custom Analysis. (Peut également être exécuté au sein d'une databank depuis Databank > Tools > Run CA).
2. Dans Full databank analysis, sélectionnez CARenameFindReplace et choisissez votre banque de données Source.
3. Dans Input args, saisissez l'une des options suivantes :
   -
   Remplacer : old=>new
   Supprimer : old
   -
4. Activez « Filter by results of custom analysis » pour renommer les stratégies d'origine. (Si vous désactivez cette option, les stratégies seront dupliquées et seuls les doublons seront renommés, laissant les originales intactes.)
5. Lancez l'exécution. Tous les noms de stratégie dans la banque de données Source sont mis à jour.

— Exemples

• Supprimer le mot « Strategy » (avec l'espace final) :
  Strategy =>
• Convertir le nom automatique SQX en un libellé formaté :
  Strategy =>XAUUSD_H1_L_
• Supprimer les points après une passe de préfixe :
  .=>

Astuce : effectuez plusieurs passes pour un formatage en plusieurs étapes (par ex., ajouter un préfixe, puis supprimer des caractères, puis ajouter un suffixe). Pensez à dupliquer la banque de données au préalable si vous souhaitez 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) throws Exception {
        // Read single Input args string
        String raw = getInputArgs();
        if (raw == null) raw = "";
        raw = raw.trim();
        // No args -> do nothing
        if (raw.isEmpty()) {
            return databankRG;
        }
        // Parse: "find=>replace" OR just "find" (remove)
        String 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);
        // If find is empty, do nothing (prevents accidental rename-all)
        if (find.isEmpty()) {
            return databankRG;
        }
        SQProject prj = ProjectEngine.get(project);
        Databank db = prj.getDatabanks().get(databankName);
        // Snapshot of originals to avoid ConcurrentModificationException
        ArrayList snapshot = new ArrayList<>(databankRG);
        // Track existing names so we can avoid collisions if needed
        HashSet usedNames = new HashSet<>();
        for (ResultsGroup rg : snapshot) {
            if (rg.getName() != null) usedNames.add(rg.getName());
        }
        // 1) Create renamed clones (no db.add inside the iteration)
        ArrayList clonesToAdd = new ArrayList<>();
        for (ResultsGroup rg : snapshot) {
            String oldName = rg.getName();
            if (oldName == null) continue;
            String newName = oldName.replace(find, repl);
            // Only duplicate if name changes
            if (!newName.equals(oldName)) {
                // Avoid exact-name collisions (optional safety)
                String finalName = makeUniqueName(newName, usedNames);
                ResultsGroup newRg = rg.clone();
                newRg.setName(finalName);
                clonesToAdd.add(newRg);
                usedNames.add(finalName);
            }
        }
        // 2) Add clones after iteration (safe)
        for (ResultsGroup newRg : clonesToAdd) {
            db.add(newRg, true);
        }
        // Return the newly created strategies (mirrors SQX RenameStrategies behaviour)
        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("\\t", "\t")
                .replace("\\r", "\r");
    }
}