Ridenominazione in blocco delle strategie

Ideale se desideri creare rapidamente nomi chiari e informativi in un'intera databank: questo snippet di Custom Analysis ti consente di rinominare in blocco le strategie in StrategyQuant X utilizzando un semplice trova → sostituisci (o semplicemente trova → rimuovi).

— Cosa fa

• Viene eseguito come Custom Analysis (Full databank analysis).

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

• Rinomina sul posto nella databank di origine (Source) selezionata.

• Corrispondenza letterale, con distinzione tra maiuscole e minuscole. Supporta \n, \t, \r.

• Ottimo per pulizie di massa: elimina prefissi/suffissi, rimuovi parole, standardizza simboli/timeframe/direzioni.

— Come installarlo

1. Code Editor → New → Custom Analysis, assegna al file il nome CARenameFindReplace
2. Incolla il codice (sotto) e fai clic su Compile.
3. Se necessario, riavvia SQX.

— Come usarlo

1. Custom Project → Task → Custom Analysis. (Può essere eseguito anche all'interno di una databank da Databank > Tools > Run CA).
2. In Full databank analysis, seleziona CARenameFindReplace e scegli la tua databank Source.
3. In Input args inserisci uno tra:
   -
   Sostituisci: vecchio=>nuovo
   Rimuovi: vecchio
   -
4. Abilita 'Filter by results of custom analysis' per rinominare le strategie originali. (Se disabiliti questa opzione, le strategie verranno duplicate e solo i duplicati saranno rinominati, lasciando intatti gli originali).
5. Esegui. Tutti i nomi delle strategie nella databank Source vengono aggiornati.

— Esempi

• Rimuovi la parola “Strategy ” (con spazio finale):
  Strategy =>
• Converti l'auto-nome di SQX in un'etichetta formattata:
  Strategy =>XAUUSD_H1_L_
• Elimina i punti dopo un passaggio con prefisso:
  .=>

Suggerimento: esegui più passaggi per una formattazione multifase (ad es., aggiungi un prefisso, poi rimuovi caratteri, quindi aggiungi un suffisso). Valuta di duplicare prima la databank se desideri un ripristino agevole.

Codice:

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");
    }
}